YES(O(1),O(n^2)) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict Trs: { #equal(@x, @y) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) } Weak Trs: { #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We add following dependency tuples: Strict DPs: { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) , appendreverse^#(@toreverse, @sofar) -> c_2(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_3(appendreverse^#(@as, ::(@a, @sofar))) , appendreverse#1^#(nil(), @sofar) -> c_4() , bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_6(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_7(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_8(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y), #equal^#(@x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#2^#(nil(), @x) -> c_11() , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14() , reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) , dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x)) , dfs#1^#(nil(), @x) -> c_20() , dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x), #equal^#(@a, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) , dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24() , dodfs^#(@t, @x) -> c_25(dfs^#(::(@t, nil()), @x)) } Weak DPs: { #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) , #eq^#(::(@x_1, @x_2), nil()) -> c_27() , #eq^#(::(@x_1, @x_2), leaf()) -> c_28() , #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() , #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() , #eq^#(nil(), nil()) -> c_31() , #eq^#(nil(), leaf()) -> c_32() , #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() , #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() , #eq^#(leaf(), nil()) -> c_35() , #eq^#(leaf(), leaf()) -> c_36() , #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() , #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() , #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() , #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() , #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) , #eq^#(#0(), #0()) -> c_42() , #eq^#(#0(), #neg(@y)) -> c_43() , #eq^#(#0(), #pos(@y)) -> c_44() , #eq^#(#0(), #s(@y)) -> c_45() , #eq^#(#neg(@x), #0()) -> c_46() , #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) , #eq^#(#neg(@x), #pos(@y)) -> c_48() , #eq^#(#pos(@x), #0()) -> c_49() , #eq^#(#pos(@x), #neg(@y)) -> c_50() , #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) , #eq^#(#s(@x), #0()) -> c_52() , #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) , #and^#(#false(), #false()) -> c_54() , #and^#(#false(), #true()) -> c_55() , #and^#(#true(), #false()) -> c_56() , #and^#(#true(), #true()) -> c_57() } and mark the set of starting terms. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) , appendreverse^#(@toreverse, @sofar) -> c_2(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_3(appendreverse^#(@as, ::(@a, @sofar))) , appendreverse#1^#(nil(), @sofar) -> c_4() , bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_6(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_7(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_8(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y), #equal^#(@x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#2^#(nil(), @x) -> c_11() , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14() , reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) , dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x)) , dfs#1^#(nil(), @x) -> c_20() , dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x), #equal^#(@a, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) , dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24() , dodfs^#(@t, @x) -> c_25(dfs^#(::(@t, nil()), @x)) } Weak DPs: { #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) , #eq^#(::(@x_1, @x_2), nil()) -> c_27() , #eq^#(::(@x_1, @x_2), leaf()) -> c_28() , #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() , #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() , #eq^#(nil(), nil()) -> c_31() , #eq^#(nil(), leaf()) -> c_32() , #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() , #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() , #eq^#(leaf(), nil()) -> c_35() , #eq^#(leaf(), leaf()) -> c_36() , #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() , #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() , #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() , #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() , #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) , #eq^#(#0(), #0()) -> c_42() , #eq^#(#0(), #neg(@y)) -> c_43() , #eq^#(#0(), #pos(@y)) -> c_44() , #eq^#(#0(), #s(@y)) -> c_45() , #eq^#(#neg(@x), #0()) -> c_46() , #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) , #eq^#(#neg(@x), #pos(@y)) -> c_48() , #eq^#(#pos(@x), #0()) -> c_49() , #eq^#(#pos(@x), #neg(@y)) -> c_50() , #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) , #eq^#(#s(@x), #0()) -> c_52() , #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) , #and^#(#false(), #false()) -> c_54() , #and^#(#false(), #true()) -> c_55() , #and^#(#true(), #false()) -> c_56() , #and^#(#true(), #true()) -> c_57() } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) Consider the dependency graph 1: #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) -->_1 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53 -->_1 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51 -->_1 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47 -->_1 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) :41 -->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) :26 -->_1 #eq^#(#s(@x), #0()) -> c_52() :52 -->_1 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50 -->_1 #eq^#(#pos(@x), #0()) -> c_49() :49 -->_1 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48 -->_1 #eq^#(#neg(@x), #0()) -> c_46() :46 -->_1 #eq^#(#0(), #s(@y)) -> c_45() :45 -->_1 #eq^#(#0(), #pos(@y)) -> c_44() :44 -->_1 #eq^#(#0(), #neg(@y)) -> c_43() :43 -->_1 #eq^#(#0(), #0()) -> c_42() :42 -->_1 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40 -->_1 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39 -->_1 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38 -->_1 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37 -->_1 #eq^#(leaf(), leaf()) -> c_36() :36 -->_1 #eq^#(leaf(), nil()) -> c_35() :35 -->_1 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34 -->_1 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33 -->_1 #eq^#(nil(), leaf()) -> c_32() :32 -->_1 #eq^#(nil(), nil()) -> c_31() :31 -->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30 -->_1 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29 -->_1 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28 -->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27 2: appendreverse^#(@toreverse, @sofar) -> c_2(appendreverse#1^#(@toreverse, @sofar)) -->_1 appendreverse#1^#(::(@a, @as), @sofar) -> c_3(appendreverse^#(@as, ::(@a, @sofar))) :3 -->_1 appendreverse#1^#(nil(), @sofar) -> c_4() :4 3: appendreverse#1^#(::(@a, @as), @sofar) -> c_3(appendreverse^#(@as, ::(@a, @sofar))) -->_1 appendreverse^#(@toreverse, @sofar) -> c_2(appendreverse#1^#(@toreverse, @sofar)) :2 4: appendreverse#1^#(nil(), @sofar) -> c_4() 5: bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) -->_1 bfs#1^#(nil(), @futurequeue, @x) -> c_7(bfs#2^#(@futurequeue, @x)) :7 -->_1 bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_6(bfs#3^#(@t, @futurequeue, @ts, @x)) :6 6: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_6(bfs#3^#(@t, @futurequeue, @ts, @x)) -->_1 bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y), #equal^#(@x, @y)) :9 -->_1 bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_8(bfs^#(@ts, @futurequeue, @x)) :8 7: bfs#1^#(nil(), @futurequeue, @x) -> c_7(bfs#2^#(@futurequeue, @x)) -->_1 bfs#2^#(::(@t, @ts), @x) -> c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) :10 -->_1 bfs#2^#(nil(), @x) -> c_11() :11 8: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_8(bfs^#(@ts, @futurequeue, @x)) -->_1 bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) :5 9: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y), #equal^#(@x, @y)) -->_1 bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) :12 -->_1 bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14() :13 -->_2 #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) :1 10: bfs#2^#(::(@t, @ts), @x) -> c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) -->_2 reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil())) :14 -->_1 bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) :5 11: bfs#2^#(nil(), @x) -> c_11() 12: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) -->_1 bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) :5 13: bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14() 14: reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil())) -->_1 appendreverse^#(@toreverse, @sofar) -> c_2(appendreverse#1^#(@toreverse, @sofar)) :2 15: bfs2^#(@t, @x) -> c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) -->_2 dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) :17 -->_1 bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x)) :16 16: bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x)) -->_1 dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) :17 17: dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) -->_1 bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) :5 18: dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) -->_1 dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x)) :19 -->_1 dfs#1^#(nil(), @x) -> c_20() :20 19: dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x)) -->_1 dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x), #equal^#(@a, @x)) :22 -->_1 dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x)) :21 20: dfs#1^#(nil(), @x) -> c_20() 21: dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x)) -->_1 dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) :18 22: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x), #equal^#(@a, @x)) -->_1 dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) :23 -->_1 dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24() :24 -->_2 #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) :1 23: dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) -->_1 dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) :18 24: dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24() 25: dodfs^#(@t, @x) -> c_25(dfs^#(::(@t, nil()), @x)) -->_1 dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) :18 26: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) -->_3 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53 -->_2 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53 -->_3 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51 -->_2 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51 -->_3 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47 -->_2 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47 -->_3 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) :41 -->_2 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) :41 -->_1 #and^#(#true(), #true()) -> c_57() :57 -->_1 #and^#(#true(), #false()) -> c_56() :56 -->_1 #and^#(#false(), #true()) -> c_55() :55 -->_1 #and^#(#false(), #false()) -> c_54() :54 -->_3 #eq^#(#s(@x), #0()) -> c_52() :52 -->_2 #eq^#(#s(@x), #0()) -> c_52() :52 -->_3 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50 -->_2 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50 -->_3 #eq^#(#pos(@x), #0()) -> c_49() :49 -->_2 #eq^#(#pos(@x), #0()) -> c_49() :49 -->_3 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48 -->_2 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48 -->_3 #eq^#(#neg(@x), #0()) -> c_46() :46 -->_2 #eq^#(#neg(@x), #0()) -> c_46() :46 -->_3 #eq^#(#0(), #s(@y)) -> c_45() :45 -->_2 #eq^#(#0(), #s(@y)) -> c_45() :45 -->_3 #eq^#(#0(), #pos(@y)) -> c_44() :44 -->_2 #eq^#(#0(), #pos(@y)) -> c_44() :44 -->_3 #eq^#(#0(), #neg(@y)) -> c_43() :43 -->_2 #eq^#(#0(), #neg(@y)) -> c_43() :43 -->_3 #eq^#(#0(), #0()) -> c_42() :42 -->_2 #eq^#(#0(), #0()) -> c_42() :42 -->_3 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40 -->_2 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40 -->_3 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39 -->_2 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39 -->_3 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38 -->_2 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38 -->_3 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37 -->_2 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37 -->_3 #eq^#(leaf(), leaf()) -> c_36() :36 -->_2 #eq^#(leaf(), leaf()) -> c_36() :36 -->_3 #eq^#(leaf(), nil()) -> c_35() :35 -->_2 #eq^#(leaf(), nil()) -> c_35() :35 -->_3 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34 -->_2 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34 -->_3 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33 -->_2 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33 -->_3 #eq^#(nil(), leaf()) -> c_32() :32 -->_2 #eq^#(nil(), leaf()) -> c_32() :32 -->_3 #eq^#(nil(), nil()) -> c_31() :31 -->_2 #eq^#(nil(), nil()) -> c_31() :31 -->_3 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30 -->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30 -->_3 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29 -->_2 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29 -->_3 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28 -->_2 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28 -->_3 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27 -->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27 -->_3 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) :26 -->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) :26 27: #eq^#(::(@x_1, @x_2), nil()) -> c_27() 28: #eq^#(::(@x_1, @x_2), leaf()) -> c_28() 29: #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() 30: #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() 31: #eq^#(nil(), nil()) -> c_31() 32: #eq^#(nil(), leaf()) -> c_32() 33: #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() 34: #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() 35: #eq^#(leaf(), nil()) -> c_35() 36: #eq^#(leaf(), leaf()) -> c_36() 37: #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() 38: #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() 39: #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() 40: #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() 41: #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) -->_5 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53 -->_4 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53 -->_2 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53 -->_5 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51 -->_4 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51 -->_2 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51 -->_5 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47 -->_4 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47 -->_2 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47 -->_3 #and^#(#true(), #true()) -> c_57() :57 -->_1 #and^#(#true(), #true()) -> c_57() :57 -->_3 #and^#(#true(), #false()) -> c_56() :56 -->_1 #and^#(#true(), #false()) -> c_56() :56 -->_3 #and^#(#false(), #true()) -> c_55() :55 -->_1 #and^#(#false(), #true()) -> c_55() :55 -->_3 #and^#(#false(), #false()) -> c_54() :54 -->_1 #and^#(#false(), #false()) -> c_54() :54 -->_5 #eq^#(#s(@x), #0()) -> c_52() :52 -->_4 #eq^#(#s(@x), #0()) -> c_52() :52 -->_2 #eq^#(#s(@x), #0()) -> c_52() :52 -->_5 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50 -->_4 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50 -->_2 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50 -->_5 #eq^#(#pos(@x), #0()) -> c_49() :49 -->_4 #eq^#(#pos(@x), #0()) -> c_49() :49 -->_2 #eq^#(#pos(@x), #0()) -> c_49() :49 -->_5 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48 -->_4 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48 -->_2 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48 -->_5 #eq^#(#neg(@x), #0()) -> c_46() :46 -->_4 #eq^#(#neg(@x), #0()) -> c_46() :46 -->_2 #eq^#(#neg(@x), #0()) -> c_46() :46 -->_5 #eq^#(#0(), #s(@y)) -> c_45() :45 -->_4 #eq^#(#0(), #s(@y)) -> c_45() :45 -->_2 #eq^#(#0(), #s(@y)) -> c_45() :45 -->_5 #eq^#(#0(), #pos(@y)) -> c_44() :44 -->_4 #eq^#(#0(), #pos(@y)) -> c_44() :44 -->_2 #eq^#(#0(), #pos(@y)) -> c_44() :44 -->_5 #eq^#(#0(), #neg(@y)) -> c_43() :43 -->_4 #eq^#(#0(), #neg(@y)) -> c_43() :43 -->_2 #eq^#(#0(), #neg(@y)) -> c_43() :43 -->_5 #eq^#(#0(), #0()) -> c_42() :42 -->_4 #eq^#(#0(), #0()) -> c_42() :42 -->_2 #eq^#(#0(), #0()) -> c_42() :42 -->_5 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) :41 -->_4 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) :41 -->_2 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) :41 -->_5 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40 -->_4 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40 -->_2 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40 -->_5 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39 -->_4 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39 -->_2 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39 -->_5 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38 -->_4 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38 -->_2 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38 -->_5 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37 -->_4 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37 -->_2 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37 -->_5 #eq^#(leaf(), leaf()) -> c_36() :36 -->_4 #eq^#(leaf(), leaf()) -> c_36() :36 -->_2 #eq^#(leaf(), leaf()) -> c_36() :36 -->_5 #eq^#(leaf(), nil()) -> c_35() :35 -->_4 #eq^#(leaf(), nil()) -> c_35() :35 -->_2 #eq^#(leaf(), nil()) -> c_35() :35 -->_5 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34 -->_4 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34 -->_2 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34 -->_5 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33 -->_4 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33 -->_2 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33 -->_5 #eq^#(nil(), leaf()) -> c_32() :32 -->_4 #eq^#(nil(), leaf()) -> c_32() :32 -->_2 #eq^#(nil(), leaf()) -> c_32() :32 -->_5 #eq^#(nil(), nil()) -> c_31() :31 -->_4 #eq^#(nil(), nil()) -> c_31() :31 -->_2 #eq^#(nil(), nil()) -> c_31() :31 -->_5 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30 -->_4 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30 -->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30 -->_5 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29 -->_4 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29 -->_2 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29 -->_5 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28 -->_4 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28 -->_2 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28 -->_5 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27 -->_4 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27 -->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27 -->_5 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) :26 -->_4 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) :26 -->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) :26 42: #eq^#(#0(), #0()) -> c_42() 43: #eq^#(#0(), #neg(@y)) -> c_43() 44: #eq^#(#0(), #pos(@y)) -> c_44() 45: #eq^#(#0(), #s(@y)) -> c_45() 46: #eq^#(#neg(@x), #0()) -> c_46() 47: #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) -->_1 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53 -->_1 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51 -->_1 #eq^#(#s(@x), #0()) -> c_52() :52 -->_1 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50 -->_1 #eq^#(#pos(@x), #0()) -> c_49() :49 -->_1 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48 -->_1 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47 -->_1 #eq^#(#neg(@x), #0()) -> c_46() :46 -->_1 #eq^#(#0(), #s(@y)) -> c_45() :45 -->_1 #eq^#(#0(), #pos(@y)) -> c_44() :44 -->_1 #eq^#(#0(), #neg(@y)) -> c_43() :43 -->_1 #eq^#(#0(), #0()) -> c_42() :42 -->_1 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) :41 -->_1 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40 -->_1 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39 -->_1 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38 -->_1 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37 -->_1 #eq^#(leaf(), leaf()) -> c_36() :36 -->_1 #eq^#(leaf(), nil()) -> c_35() :35 -->_1 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34 -->_1 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33 -->_1 #eq^#(nil(), leaf()) -> c_32() :32 -->_1 #eq^#(nil(), nil()) -> c_31() :31 -->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30 -->_1 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29 -->_1 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28 -->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27 -->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) :26 48: #eq^#(#neg(@x), #pos(@y)) -> c_48() 49: #eq^#(#pos(@x), #0()) -> c_49() 50: #eq^#(#pos(@x), #neg(@y)) -> c_50() 51: #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) -->_1 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53 -->_1 #eq^#(#s(@x), #0()) -> c_52() :52 -->_1 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51 -->_1 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50 -->_1 #eq^#(#pos(@x), #0()) -> c_49() :49 -->_1 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48 -->_1 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47 -->_1 #eq^#(#neg(@x), #0()) -> c_46() :46 -->_1 #eq^#(#0(), #s(@y)) -> c_45() :45 -->_1 #eq^#(#0(), #pos(@y)) -> c_44() :44 -->_1 #eq^#(#0(), #neg(@y)) -> c_43() :43 -->_1 #eq^#(#0(), #0()) -> c_42() :42 -->_1 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) :41 -->_1 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40 -->_1 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39 -->_1 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38 -->_1 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37 -->_1 #eq^#(leaf(), leaf()) -> c_36() :36 -->_1 #eq^#(leaf(), nil()) -> c_35() :35 -->_1 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34 -->_1 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33 -->_1 #eq^#(nil(), leaf()) -> c_32() :32 -->_1 #eq^#(nil(), nil()) -> c_31() :31 -->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30 -->_1 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29 -->_1 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28 -->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27 -->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) :26 52: #eq^#(#s(@x), #0()) -> c_52() 53: #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) -->_1 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53 -->_1 #eq^#(#s(@x), #0()) -> c_52() :52 -->_1 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51 -->_1 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50 -->_1 #eq^#(#pos(@x), #0()) -> c_49() :49 -->_1 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48 -->_1 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47 -->_1 #eq^#(#neg(@x), #0()) -> c_46() :46 -->_1 #eq^#(#0(), #s(@y)) -> c_45() :45 -->_1 #eq^#(#0(), #pos(@y)) -> c_44() :44 -->_1 #eq^#(#0(), #neg(@y)) -> c_43() :43 -->_1 #eq^#(#0(), #0()) -> c_42() :42 -->_1 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) :41 -->_1 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40 -->_1 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39 -->_1 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38 -->_1 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37 -->_1 #eq^#(leaf(), leaf()) -> c_36() :36 -->_1 #eq^#(leaf(), nil()) -> c_35() :35 -->_1 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34 -->_1 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33 -->_1 #eq^#(nil(), leaf()) -> c_32() :32 -->_1 #eq^#(nil(), nil()) -> c_31() :31 -->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30 -->_1 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29 -->_1 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28 -->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27 -->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) :26 54: #and^#(#false(), #false()) -> c_54() 55: #and^#(#false(), #true()) -> c_55() 56: #and^#(#true(), #false()) -> c_56() 57: #and^#(#true(), #true()) -> c_57() Following roots of the dependency graph are removed, as the considered set of starting terms is closed under reduction with respect to these rules (modulo compound contexts). { dodfs^#(@t, @x) -> c_25(dfs^#(::(@t, nil()), @x)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) , appendreverse^#(@toreverse, @sofar) -> c_2(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_3(appendreverse^#(@as, ::(@a, @sofar))) , appendreverse#1^#(nil(), @sofar) -> c_4() , bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_6(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_7(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_8(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y), #equal^#(@x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#2^#(nil(), @x) -> c_11() , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14() , reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) , dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x)) , dfs#1^#(nil(), @x) -> c_20() , dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x), #equal^#(@a, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) , dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24() } Weak DPs: { #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) , #eq^#(::(@x_1, @x_2), nil()) -> c_27() , #eq^#(::(@x_1, @x_2), leaf()) -> c_28() , #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() , #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() , #eq^#(nil(), nil()) -> c_31() , #eq^#(nil(), leaf()) -> c_32() , #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() , #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() , #eq^#(leaf(), nil()) -> c_35() , #eq^#(leaf(), leaf()) -> c_36() , #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() , #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() , #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() , #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() , #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) , #eq^#(#0(), #0()) -> c_42() , #eq^#(#0(), #neg(@y)) -> c_43() , #eq^#(#0(), #pos(@y)) -> c_44() , #eq^#(#0(), #s(@y)) -> c_45() , #eq^#(#neg(@x), #0()) -> c_46() , #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) , #eq^#(#neg(@x), #pos(@y)) -> c_48() , #eq^#(#pos(@x), #0()) -> c_49() , #eq^#(#pos(@x), #neg(@y)) -> c_50() , #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) , #eq^#(#s(@x), #0()) -> c_52() , #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) , #and^#(#false(), #false()) -> c_54() , #and^#(#false(), #true()) -> c_55() , #and^#(#true(), #false()) -> c_56() , #and^#(#true(), #true()) -> c_57() } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We estimate the number of application of {1,4,11,13,20,24} by applications of Pre({1,4,11,13,20,24}) = {2,7,9,18,22}. Here rules are labeled as follows: DPs: { 1: #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) , 2: appendreverse^#(@toreverse, @sofar) -> c_2(appendreverse#1^#(@toreverse, @sofar)) , 3: appendreverse#1^#(::(@a, @as), @sofar) -> c_3(appendreverse^#(@as, ::(@a, @sofar))) , 4: appendreverse#1^#(nil(), @sofar) -> c_4() , 5: bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) , 6: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_6(bfs#3^#(@t, @futurequeue, @ts, @x)) , 7: bfs#1^#(nil(), @futurequeue, @x) -> c_7(bfs#2^#(@futurequeue, @x)) , 8: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_8(bfs^#(@ts, @futurequeue, @x)) , 9: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y), #equal^#(@x, @y)) , 10: bfs#2^#(::(@t, @ts), @x) -> c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , 11: bfs#2^#(nil(), @x) -> c_11() , 12: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , 13: bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14() , 14: reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil())) , 15: bfs2^#(@t, @x) -> c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , 16: bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x)) , 17: dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) , 18: dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) , 19: dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x)) , 20: dfs#1^#(nil(), @x) -> c_20() , 21: dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x)) , 22: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x), #equal^#(@a, @x)) , 23: dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) , 24: dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24() , 25: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) , 26: #eq^#(::(@x_1, @x_2), nil()) -> c_27() , 27: #eq^#(::(@x_1, @x_2), leaf()) -> c_28() , 28: #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() , 29: #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() , 30: #eq^#(nil(), nil()) -> c_31() , 31: #eq^#(nil(), leaf()) -> c_32() , 32: #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() , 33: #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() , 34: #eq^#(leaf(), nil()) -> c_35() , 35: #eq^#(leaf(), leaf()) -> c_36() , 36: #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() , 37: #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() , 38: #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() , 39: #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() , 40: #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) , 41: #eq^#(#0(), #0()) -> c_42() , 42: #eq^#(#0(), #neg(@y)) -> c_43() , 43: #eq^#(#0(), #pos(@y)) -> c_44() , 44: #eq^#(#0(), #s(@y)) -> c_45() , 45: #eq^#(#neg(@x), #0()) -> c_46() , 46: #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) , 47: #eq^#(#neg(@x), #pos(@y)) -> c_48() , 48: #eq^#(#pos(@x), #0()) -> c_49() , 49: #eq^#(#pos(@x), #neg(@y)) -> c_50() , 50: #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) , 51: #eq^#(#s(@x), #0()) -> c_52() , 52: #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) , 53: #and^#(#false(), #false()) -> c_54() , 54: #and^#(#false(), #true()) -> c_55() , 55: #and^#(#true(), #false()) -> c_56() , 56: #and^#(#true(), #true()) -> c_57() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_2(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_3(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_6(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_7(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_8(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y), #equal^#(@x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) , dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x), #equal^#(@a, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak DPs: { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) , #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) , #eq^#(::(@x_1, @x_2), nil()) -> c_27() , #eq^#(::(@x_1, @x_2), leaf()) -> c_28() , #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() , #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() , #eq^#(nil(), nil()) -> c_31() , #eq^#(nil(), leaf()) -> c_32() , #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() , #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() , #eq^#(leaf(), nil()) -> c_35() , #eq^#(leaf(), leaf()) -> c_36() , #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() , #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() , #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() , #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() , #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) , #eq^#(#0(), #0()) -> c_42() , #eq^#(#0(), #neg(@y)) -> c_43() , #eq^#(#0(), #pos(@y)) -> c_44() , #eq^#(#0(), #s(@y)) -> c_45() , #eq^#(#neg(@x), #0()) -> c_46() , #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) , #eq^#(#neg(@x), #pos(@y)) -> c_48() , #eq^#(#pos(@x), #0()) -> c_49() , #eq^#(#pos(@x), #neg(@y)) -> c_50() , #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) , #eq^#(#s(@x), #0()) -> c_52() , #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) , appendreverse#1^#(nil(), @sofar) -> c_4() , bfs#2^#(nil(), @x) -> c_11() , bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14() , dfs#1^#(nil(), @x) -> c_20() , dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24() , #and^#(#false(), #false()) -> c_54() , #and^#(#false(), #true()) -> c_55() , #and^#(#true(), #false()) -> c_56() , #and^#(#true(), #true()) -> c_57() } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) , #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) -> c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)), #eq^#(@x_1, @y_1), #eq^#(@x_2, @y_2)) , #eq^#(::(@x_1, @x_2), nil()) -> c_27() , #eq^#(::(@x_1, @x_2), leaf()) -> c_28() , #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() , #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() , #eq^#(nil(), nil()) -> c_31() , #eq^#(nil(), leaf()) -> c_32() , #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() , #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() , #eq^#(leaf(), nil()) -> c_35() , #eq^#(leaf(), leaf()) -> c_36() , #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() , #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() , #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() , #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() , #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> c_41(#and^#(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))), #eq^#(@x_1, @y_1), #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)), #eq^#(@x_2, @y_2), #eq^#(@x_3, @y_3)) , #eq^#(#0(), #0()) -> c_42() , #eq^#(#0(), #neg(@y)) -> c_43() , #eq^#(#0(), #pos(@y)) -> c_44() , #eq^#(#0(), #s(@y)) -> c_45() , #eq^#(#neg(@x), #0()) -> c_46() , #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) , #eq^#(#neg(@x), #pos(@y)) -> c_48() , #eq^#(#pos(@x), #0()) -> c_49() , #eq^#(#pos(@x), #neg(@y)) -> c_50() , #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) , #eq^#(#s(@x), #0()) -> c_52() , #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) , appendreverse#1^#(nil(), @sofar) -> c_4() , bfs#2^#(nil(), @x) -> c_11() , bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14() , dfs#1^#(nil(), @x) -> c_20() , dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24() , #and^#(#false(), #false()) -> c_54() , #and^#(#false(), #true()) -> c_55() , #and^#(#true(), #false()) -> c_56() , #and^#(#true(), #true()) -> c_57() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_2(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_3(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_5(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_6(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_7(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_8(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y), #equal^#(@x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) , dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x), #equal^#(@a, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y), #equal^#(@x, @y)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x), #equal^#(@a, @x)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) , dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We analyse the complexity of following sub-problems (R) and (S). Problem (S) is obtained from the input problem by shifting strict rules from (R) into the weak component: Problem (R): ------------ Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } Weak DPs: { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } StartTerms: basic terms Strategy: innermost Problem (S): ------------ Strict DPs: { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } StartTerms: basic terms Strategy: innermost Overall, the transformation results in the following sub-problem(s): Generated new problems: ----------------------- R) Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } Weak DPs: { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } StartTerms: basic terms Strategy: innermost This problem was proven YES(O(1),O(n^2)). S) Strict DPs: { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } StartTerms: basic terms Strategy: innermost This problem was proven YES(O(1),O(n^1)). Proofs for generated problems: ------------------------------ R) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } Weak DPs: { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We replace rewrite rules by usable rules: Weak Usable Rules: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^2)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^2)) We decompose the input problem according to the dependency graph into the upper component { bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } and lower component { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) } Further, following extension rules are added to the lower component. { bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> bfs#3^#(@t, @futurequeue, @ts, @x) , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2^#(::(@t, @ts), @x) -> bfs^#(reverse(::(@t, @ts)), nil(), @x) , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x) , bfs2^#(@t, @x) -> dobfs^#(@t, @x) , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) } TcT solves the upper component with certificate YES(O(1),O(n^1)). Sub-proof: ---------- We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Due to missing edges in the dependency-graph, the right-hand sides of following rules could be simplified: { bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 5: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) } Trs: { bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1}, Uargs(c_10) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#equal](x1, x2) = [0] [#eq](x1, x2) = [0] [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [0] [nil] = [0] [bfs](x1, x2, x3) = [1] x1 + [1] x2 + [0] [bfs#1](x1, x2, x3) = [1] x1 + [1] x2 + [0] [bfs#3](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [0] [bfs#2](x1, x2) = [1] x1 + [0] [reverse](x1) = [1] x1 + [0] [leaf] = [0] [node](x1, x2, x3) = [1] x2 + [1] x3 + [1] [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [1] [#false] = [0] [#true] = [0] [dobfs](x1, x2) = [1] x1 + [0] [#and](x1, x2) = [0] [#0] = [2] [#neg](x1) = [1] x1 + [2] [#pos](x1) = [1] x1 + [2] [#s](x1) = [1] x1 + [2] [#equal^#](x1, x2) = [0] [#eq^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bfs^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] [bfs#1^#](x1, x2, x3) = [1] x1 + [1] x2 + [1] [bfs#3^#](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1] [bfs#2^#](x1, x2) = [1] x1 + [1] [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [1] [reverse^#](x1) = [0] [bfs2^#](x1, x2) = [2] x1 + [2] x2 + [2] [bfs2#1^#](x1, x2) = [1] x1 + [1] x2 + [1] [dobfs^#](x1, x2) = [1] x1 + [1] [dfs^#](x1, x2) = [0] [dfs#1^#](x1, x2) = [0] [dfs#2^#](x1, x2, x3, x4) = [0] [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0] [dodfs^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [c_3](x1) = [0] [c_4](x1) = [0] [c_5](x1) = [0] [c_6](x1) = [0] [c_7](x1) = [0] [c_8](x1, x2) = [0] [c_9](x1) = [0] [c_11](x1, x2) = [0] [c_12](x1) = [0] [c_13](x1) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1, x2) = [1] x1 + [1] x2 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] This order satisfies following ordering constraints [appendreverse(@toreverse, @sofar)] = [1] @sofar + [1] @toreverse + [0] >= [1] @sofar + [1] @toreverse + [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] @sofar + [0] >= [1] @a + [1] @as + [1] @sofar + [0] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1] @sofar + [0] >= [1] @sofar + [0] = [@sofar] [bfs(@queue, @futurequeue, @x)] = [1] @futurequeue + [1] @queue + [0] >= [1] @futurequeue + [1] @queue + [0] = [bfs#1(@queue, @futurequeue, @x)] [bfs#1(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [0] >= [1] @futurequeue + [1] @t + [1] @ts + [0] = [bfs#3(@t, @futurequeue, @ts, @x)] [bfs#1(nil(), @futurequeue, @x)] = [1] @futurequeue + [0] >= [1] @futurequeue + [0] = [bfs#2(@futurequeue, @x)] [bfs#3(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [0] >= [1] @futurequeue + [1] @ts + [0] = [bfs(@ts, @futurequeue, @x)] [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] = [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)] [bfs#2(::(@t, @ts), @x)] = [1] @t + [1] @ts + [0] >= [1] @t + [1] @ts + [0] = [bfs(reverse(::(@t, @ts)), nil(), @x)] [bfs#2(nil(), @x)] = [0] >= [0] = [leaf()] [reverse(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [appendreverse(@xs, nil())] [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] > [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [0] = [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)] [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] >= [1] @t1 + [1] @t2 + [1] = [node(@y, @t1, @t2)] [dobfs(@t, @x)] = [1] @t + [0] >= [1] @t + [0] = [bfs(::(@t, nil()), nil(), @x)] [bfs^#(@queue, @futurequeue, @x)] = [1] @futurequeue + [1] @queue + [1] >= [1] @futurequeue + [1] @queue + [1] = [c_1(bfs#1^#(@queue, @futurequeue, @x))] [bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [1] >= [1] @futurequeue + [1] @t + [1] @ts + [1] = [c_2(bfs#3^#(@t, @futurequeue, @ts, @x))] [bfs#1^#(nil(), @futurequeue, @x)] = [1] @futurequeue + [1] >= [1] @futurequeue + [1] = [c_3(bfs#2^#(@futurequeue, @x))] [bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] >= [1] @futurequeue + [1] @ts + [1] = [c_4(bfs^#(@ts, @futurequeue, @x))] [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2] > [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] = [c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))] [bfs#2^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [1] >= [1] @t + [1] @ts + [1] = [c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))] [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] = [c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))] [bfs2^#(@t, @x)] = [2] @t + [2] @x + [2] >= [2] @t + [1] @x + [2] = [c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))] [bfs2#1^#(@t', @x)] = [1] @t' + [1] @x + [1] >= [1] @t' + [1] = [c_9(dobfs^#(@t', @x))] [dobfs^#(@t, @x)] = [1] @t + [1] >= [1] @t + [1] = [c_10(bfs^#(::(@t, nil()), nil(), @x))] Consider the set of all dependency pairs DPs: { 1: bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , 2: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , 3: bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , 4: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , 5: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , 6: bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , 8: bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , 9: bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {5}. These cover all (indirect) predecessors of dependency pairs {5,7,8,9,10}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) } Weak DPs: { bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 4: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , 8: bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) } Trs: { bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1}, Uargs(c_10) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#equal](x1, x2) = [0] [#eq](x1, x2) = [0] [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [0] [nil] = [0] [bfs](x1, x2, x3) = [1] x1 + [1] x2 + [1] [bfs#1](x1, x2, x3) = [1] x1 + [1] x2 + [1] [bfs#3](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [0] [bfs#2](x1, x2) = [1] x1 + [1] [reverse](x1) = [1] x1 + [0] [leaf] = [1] [node](x1, x2, x3) = [1] x2 + [1] x3 + [1] [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [1] [#false] = [0] [#true] = [0] [dobfs](x1, x2) = [1] x1 + [1] [#and](x1, x2) = [0] [#0] = [0] [#neg](x1) = [1] x1 + [0] [#pos](x1) = [1] x1 + [0] [#s](x1) = [1] x1 + [0] [#equal^#](x1, x2) = [0] [#eq^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bfs^#](x1, x2, x3) = [1] x1 + [1] x2 + [0] [bfs#1^#](x1, x2, x3) = [1] x1 + [1] x2 + [0] [bfs#3^#](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [0] [bfs#2^#](x1, x2) = [1] x1 + [0] [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [2] x1 + [1] x2 + [1] x3 + [1] x4 + [1] x5 + [1] [reverse^#](x1) = [0] [bfs2^#](x1, x2) = [2] x1 + [2] x2 + [2] [bfs2#1^#](x1, x2) = [1] x1 + [0] [dobfs^#](x1, x2) = [1] x1 + [0] [dfs^#](x1, x2) = [0] [dfs#1^#](x1, x2) = [0] [dfs#2^#](x1, x2, x3, x4) = [0] [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0] [dodfs^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [c_3](x1) = [0] [c_4](x1) = [0] [c_5](x1) = [0] [c_6](x1) = [0] [c_7](x1) = [0] [c_8](x1, x2) = [0] [c_9](x1) = [0] [c_11](x1, x2) = [0] [c_12](x1) = [0] [c_13](x1) = [0] [c] = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_3](x1) = [1] x1 + [0] [c_4](x1) = [1] x1 + [0] [c_5](x1) = [1] x1 + [0] [c_6](x1) = [1] x1 + [0] [c_7](x1) = [1] x1 + [0] [c_8](x1, x2) = [1] x1 + [1] x2 + [0] [c_9](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] This order satisfies following ordering constraints [#equal(@x, @y)] = [0] >= [0] = [#eq(@x, @y)] [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0] >= [0] = [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))] [#eq(::(@x_1, @x_2), nil())] = [0] >= [0] = [#false()] [#eq(::(@x_1, @x_2), leaf())] = [0] >= [0] = [#false()] [#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [0] >= [0] = [#false()] [#eq(nil(), ::(@y_1, @y_2))] = [0] >= [0] = [#false()] [#eq(nil(), nil())] = [0] >= [0] = [#true()] [#eq(nil(), leaf())] = [0] >= [0] = [#false()] [#eq(nil(), node(@y_1, @y_2, @y_3))] = [0] >= [0] = [#false()] [#eq(leaf(), ::(@y_1, @y_2))] = [0] >= [0] = [#false()] [#eq(leaf(), nil())] = [0] >= [0] = [#false()] [#eq(leaf(), leaf())] = [0] >= [0] = [#true()] [#eq(leaf(), node(@y_1, @y_2, @y_3))] = [0] >= [0] = [#false()] [#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [0] >= [0] = [#false()] [#eq(node(@x_1, @x_2, @x_3), nil())] = [0] >= [0] = [#false()] [#eq(node(@x_1, @x_2, @x_3), leaf())] = [0] >= [0] = [#false()] [#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [0] >= [0] = [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))] [#eq(#0(), #0())] = [0] >= [0] = [#true()] [#eq(#0(), #neg(@y))] = [0] >= [0] = [#false()] [#eq(#0(), #pos(@y))] = [0] >= [0] = [#false()] [#eq(#0(), #s(@y))] = [0] >= [0] = [#false()] [#eq(#neg(@x), #0())] = [0] >= [0] = [#false()] [#eq(#neg(@x), #neg(@y))] = [0] >= [0] = [#eq(@x, @y)] [#eq(#neg(@x), #pos(@y))] = [0] >= [0] = [#false()] [#eq(#pos(@x), #0())] = [0] >= [0] = [#false()] [#eq(#pos(@x), #neg(@y))] = [0] >= [0] = [#false()] [#eq(#pos(@x), #pos(@y))] = [0] >= [0] = [#eq(@x, @y)] [#eq(#s(@x), #0())] = [0] >= [0] = [#false()] [#eq(#s(@x), #s(@y))] = [0] >= [0] = [#eq(@x, @y)] [appendreverse(@toreverse, @sofar)] = [1] @sofar + [1] @toreverse + [0] >= [1] @sofar + [1] @toreverse + [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] @sofar + [0] >= [1] @a + [1] @as + [1] @sofar + [0] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1] @sofar + [0] >= [1] @sofar + [0] = [@sofar] [bfs(@queue, @futurequeue, @x)] = [1] @futurequeue + [1] @queue + [1] >= [1] @futurequeue + [1] @queue + [1] = [bfs#1(@queue, @futurequeue, @x)] [bfs#1(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [1] > [1] @futurequeue + [1] @t + [1] @ts + [0] = [bfs#3(@t, @futurequeue, @ts, @x)] [bfs#1(nil(), @futurequeue, @x)] = [1] @futurequeue + [1] >= [1] @futurequeue + [1] = [bfs#2(@futurequeue, @x)] [bfs#3(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] >= [1] @futurequeue + [1] @ts + [1] = [bfs(@ts, @futurequeue, @x)] [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] = [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)] [bfs#2(::(@t, @ts), @x)] = [1] @t + [1] @ts + [1] >= [1] @t + [1] @ts + [1] = [bfs(reverse(::(@t, @ts)), nil(), @x)] [bfs#2(nil(), @x)] = [1] >= [1] = [leaf()] [reverse(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [appendreverse(@xs, nil())] [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] = [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)] [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] >= [1] @t1 + [1] @t2 + [1] = [node(@y, @t1, @t2)] [dobfs(@t, @x)] = [1] @t + [1] >= [1] @t + [1] = [bfs(::(@t, nil()), nil(), @x)] [#and(#false(), #false())] = [0] >= [0] = [#false()] [#and(#false(), #true())] = [0] >= [0] = [#false()] [#and(#true(), #false())] = [0] >= [0] = [#false()] [#and(#true(), #true())] = [0] >= [0] = [#true()] [bfs^#(@queue, @futurequeue, @x)] = [1] @futurequeue + [1] @queue + [0] >= [1] @futurequeue + [1] @queue + [0] = [c_1(bfs#1^#(@queue, @futurequeue, @x))] [bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [0] >= [1] @futurequeue + [1] @t + [1] @ts + [0] = [c_2(bfs#3^#(@t, @futurequeue, @ts, @x))] [bfs#1^#(nil(), @futurequeue, @x)] = [1] @futurequeue + [0] >= [1] @futurequeue + [0] = [c_3(bfs#2^#(@futurequeue, @x))] [bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] > [1] @futurequeue + [1] @ts + [0] = [c_4(bfs^#(@ts, @futurequeue, @x))] [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] = [c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))] [bfs#2^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [0] >= [1] @t + [1] @ts + [0] = [c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))] [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1] > [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [0] = [c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))] [bfs2^#(@t, @x)] = [2] @t + [2] @x + [2] > [2] @t + [1] = [c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))] [bfs2#1^#(@t', @x)] = [1] @t' + [0] >= [1] @t' + [0] = [c_9(dobfs^#(@t', @x))] [dobfs^#(@t, @x)] = [1] @t + [0] >= [1] @t + [0] = [c_10(bfs^#(::(@t, nil()), nil(), @x))] Consider the set of all dependency pairs DPs: { 1: bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , 2: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , 3: bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , 4: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , 5: bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , 6: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , 8: bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , 9: bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {4,7,8}. These cover all (indirect) predecessors of dependency pairs {4,7,8,9,10}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) } Weak DPs: { bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 2: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) } Trs: { #eq(nil(), nil()) -> #true() , #eq(leaf(), leaf()) -> #true() , #eq(#0(), #0()) -> #true() , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , #and(#true(), #true()) -> #true() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1}, Uargs(c_10) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#equal](x1, x2) = [0 0] x1 + [0] [1 0] [1] [#eq](x1, x2) = [0 0] x1 + [2] [1 1] [1] [appendreverse](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [appendreverse#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [::](x1, x2) = [1 0] x1 + [1 0] x2 + [1] [1 0] [0 1] [0] [nil] = [0] [0] [bfs](x1, x2, x3) = [0 1] x1 + [0 1] x2 + [0] [0 0] [0 0] [0] [bfs#1](x1, x2, x3) = [0 1] x1 + [0 1] x2 + [0] [0 0] [0 0] [0] [bfs#3](x1, x2, x3, x4) = [1 0] x1 + [0 1] x2 + [0 1] x3 + [0] [0 0] [0 0] [0 0] [0] [bfs#2](x1, x2) = [0 1] x1 + [0] [0 0] [0] [reverse](x1) = [1 0] x1 + [0] [0 1] [0] [leaf] = [0] [0] [node](x1, x2, x3) = [1 0] x2 + [1 0] x3 + [2] [0 0] [0 0] [0] [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [0 1] x2 + [1 0] x3 + [1 0] x4 + [0 1] x5 + [2] [0 0] [0 0] [0 0] [0 0] [0] [#false] = [2] [0] [#true] = [0] [0] [dobfs](x1, x2) = [1 0] x1 + [0] [0 0] [0] [#and](x1, x2) = [2] [0] [#0] = [1] [2] [#neg](x1) = [0 0] x1 + [0] [1 1] [0] [#pos](x1) = [0 0] x1 + [0] [1 1] [0] [#s](x1) = [1 0] x1 + [0] [0 1] [0] [#equal^#](x1, x2) = [0] [0] [#eq^#](x1, x2) = [0] [0] [appendreverse^#](x1, x2) = [0] [0] [appendreverse#1^#](x1, x2) = [0] [0] [bfs^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [bfs#1^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [bfs#3^#](x1, x2, x3, x4) = [1 0] x1 + [1 0] x2 + [1 0] x3 + [0] [0 0] [0 0] [0 0] [0] [bfs#2^#](x1, x2) = [1 0] x1 + [0] [0 0] [0] [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1 0] x2 + [1 0] x3 + [1 0] x4 + [1 0] x5 + [2] [0 0] [0 0] [0 0] [0 0] [0] [reverse^#](x1) = [0] [0] [bfs2^#](x1, x2) = [2 0] x1 + [1 0] x2 + [2] [1 1] [2 2] [1] [bfs2#1^#](x1, x2) = [1 0] x1 + [1] [0 0] [0] [dobfs^#](x1, x2) = [1 0] x1 + [1] [0 2] [0] [dfs^#](x1, x2) = [0] [0] [dfs#1^#](x1, x2) = [0] [0] [dfs#2^#](x1, x2, x3, x4) = [0] [0] [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0] [0] [dodfs^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1, x2) = [0] [0] [c_9](x1) = [0] [0] [c_11](x1, x2) = [0] [0] [c_12](x1) = [0] [0] [c_13](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1) = [1 0] x1 + [0] [0 0] [0] [c_3](x1) = [1 0] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_5](x1) = [1 0] x1 + [0] [0 0] [0] [c_6](x1) = [1 1] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_9](x1) = [1 0] x1 + [0] [0 0] [0] [c_10](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0 0] @x_1 + [0 0] @x_2 + [2] [2 0] [1 1] [2] >= [2] [0] = [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))] [#eq(::(@x_1, @x_2), nil())] = [0 0] @x_1 + [0 0] @x_2 + [2] [2 0] [1 1] [2] >= [2] [0] = [#false()] [#eq(::(@x_1, @x_2), leaf())] = [0 0] @x_1 + [0 0] @x_2 + [2] [2 0] [1 1] [2] >= [2] [0] = [#false()] [#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [0 0] @x_1 + [0 0] @x_2 + [2] [2 0] [1 1] [2] >= [2] [0] = [#false()] [#eq(nil(), ::(@y_1, @y_2))] = [2] [1] >= [2] [0] = [#false()] [#eq(nil(), nil())] = [2] [1] > [0] [0] = [#true()] [#eq(nil(), leaf())] = [2] [1] >= [2] [0] = [#false()] [#eq(nil(), node(@y_1, @y_2, @y_3))] = [2] [1] >= [2] [0] = [#false()] [#eq(leaf(), ::(@y_1, @y_2))] = [2] [1] >= [2] [0] = [#false()] [#eq(leaf(), nil())] = [2] [1] >= [2] [0] = [#false()] [#eq(leaf(), leaf())] = [2] [1] > [0] [0] = [#true()] [#eq(leaf(), node(@y_1, @y_2, @y_3))] = [2] [1] >= [2] [0] = [#false()] [#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [0 0] @x_2 + [0 0] @x_3 + [2] [1 0] [1 0] [3] >= [2] [0] = [#false()] [#eq(node(@x_1, @x_2, @x_3), nil())] = [0 0] @x_2 + [0 0] @x_3 + [2] [1 0] [1 0] [3] >= [2] [0] = [#false()] [#eq(node(@x_1, @x_2, @x_3), leaf())] = [0 0] @x_2 + [0 0] @x_3 + [2] [1 0] [1 0] [3] >= [2] [0] = [#false()] [#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [0 0] @x_2 + [0 0] @x_3 + [2] [1 0] [1 0] [3] >= [2] [0] = [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))] [#eq(#0(), #0())] = [2] [4] > [0] [0] = [#true()] [#eq(#0(), #neg(@y))] = [2] [4] >= [2] [0] = [#false()] [#eq(#0(), #pos(@y))] = [2] [4] >= [2] [0] = [#false()] [#eq(#0(), #s(@y))] = [2] [4] >= [2] [0] = [#false()] [#eq(#neg(@x), #0())] = [0 0] @x + [2] [1 1] [1] >= [2] [0] = [#false()] [#eq(#neg(@x), #neg(@y))] = [0 0] @x + [2] [1 1] [1] >= [0 0] @x + [2] [1 1] [1] = [#eq(@x, @y)] [#eq(#neg(@x), #pos(@y))] = [0 0] @x + [2] [1 1] [1] >= [2] [0] = [#false()] [#eq(#pos(@x), #0())] = [0 0] @x + [2] [1 1] [1] >= [2] [0] = [#false()] [#eq(#pos(@x), #neg(@y))] = [0 0] @x + [2] [1 1] [1] >= [2] [0] = [#false()] [#eq(#pos(@x), #pos(@y))] = [0 0] @x + [2] [1 1] [1] >= [0 0] @x + [2] [1 1] [1] = [#eq(@x, @y)] [#eq(#s(@x), #0())] = [0 0] @x + [2] [1 1] [1] >= [2] [0] = [#false()] [#eq(#s(@x), #s(@y))] = [0 0] @x + [2] [1 1] [1] >= [0 0] @x + [2] [1 1] [1] = [#eq(@x, @y)] [appendreverse(@toreverse, @sofar)] = [1 0] @sofar + [1 0] @toreverse + [0] [0 1] [0 1] [0] >= [1 0] @sofar + [1 0] @toreverse + [0] [0 1] [0 1] [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [1 0] @a + [1 0] @as + [1 0] @sofar + [1] [1 0] [0 1] [0 1] [0] >= [1 0] @a + [1 0] @as + [1 0] @sofar + [1] [1 0] [0 1] [0 1] [0] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1 0] @sofar + [0] [0 1] [0] >= [1 0] @sofar + [0] [0 1] [0] = [@sofar] [bfs(@queue, @futurequeue, @x)] = [0 1] @futurequeue + [0 1] @queue + [0] [0 0] [0 0] [0] >= [0 1] @futurequeue + [0 1] @queue + [0] [0 0] [0 0] [0] = [bfs#1(@queue, @futurequeue, @x)] [bfs#1(::(@t, @ts), @futurequeue, @x)] = [0 1] @futurequeue + [1 0] @t + [0 1] @ts + [0] [0 0] [0 0] [0 0] [0] >= [0 1] @futurequeue + [1 0] @t + [0 1] @ts + [0] [0 0] [0 0] [0 0] [0] = [bfs#3(@t, @futurequeue, @ts, @x)] [bfs#1(nil(), @futurequeue, @x)] = [0 1] @futurequeue + [0] [0 0] [0] >= [0 1] @futurequeue + [0] [0 0] [0] = [bfs#2(@futurequeue, @x)] [bfs#3(leaf(), @futurequeue, @ts, @x)] = [0 1] @futurequeue + [0 1] @ts + [0] [0 0] [0 0] [0] >= [0 1] @futurequeue + [0 1] @ts + [0] [0 0] [0 0] [0] = [bfs(@ts, @futurequeue, @x)] [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [0 1] @futurequeue + [1 0] @t1 + [1 0] @t2 + [0 1] @ts + [2] [0 0] [0 0] [0 0] [0 0] [0] >= [0 1] @futurequeue + [1 0] @t1 + [1 0] @t2 + [0 1] @ts + [2] [0 0] [0 0] [0 0] [0 0] [0] = [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)] [bfs#2(::(@t, @ts), @x)] = [1 0] @t + [0 1] @ts + [0] [0 0] [0 0] [0] >= [1 0] @t + [0 1] @ts + [0] [0 0] [0 0] [0] = [bfs(reverse(::(@t, @ts)), nil(), @x)] [bfs#2(nil(), @x)] = [0] [0] >= [0] [0] = [leaf()] [reverse(@xs)] = [1 0] @xs + [0] [0 1] [0] >= [1 0] @xs + [0] [0 1] [0] = [appendreverse(@xs, nil())] [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [0 1] @futurequeue + [1 0] @t1 + [1 0] @t2 + [0 1] @ts + [2] [0 0] [0 0] [0 0] [0 0] [0] > [0 1] @futurequeue + [1 0] @t1 + [1 0] @t2 + [0 1] @ts + [0] [0 0] [0 0] [0 0] [0 0] [0] = [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)] [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [0 1] @futurequeue + [1 0] @t1 + [1 0] @t2 + [0 1] @ts + [2] [0 0] [0 0] [0 0] [0 0] [0] >= [1 0] @t1 + [1 0] @t2 + [2] [0 0] [0 0] [0] = [node(@y, @t1, @t2)] [dobfs(@t, @x)] = [1 0] @t + [0] [0 0] [0] >= [1 0] @t + [0] [0 0] [0] = [bfs(::(@t, nil()), nil(), @x)] [#and(#false(), #false())] = [2] [0] >= [2] [0] = [#false()] [#and(#false(), #true())] = [2] [0] >= [2] [0] = [#false()] [#and(#true(), #false())] = [2] [0] >= [2] [0] = [#false()] [#and(#true(), #true())] = [2] [0] > [0] [0] = [#true()] [bfs^#(@queue, @futurequeue, @x)] = [1 0] @futurequeue + [1 0] @queue + [0] [0 0] [0 0] [0] >= [1 0] @futurequeue + [1 0] @queue + [0] [0 0] [0 0] [0] = [c_1(bfs#1^#(@queue, @futurequeue, @x))] [bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1 0] @futurequeue + [1 0] @t + [1 0] @ts + [1] [0 0] [0 0] [0 0] [0] > [1 0] @futurequeue + [1 0] @t + [1 0] @ts + [0] [0 0] [0 0] [0 0] [0] = [c_2(bfs#3^#(@t, @futurequeue, @ts, @x))] [bfs#1^#(nil(), @futurequeue, @x)] = [1 0] @futurequeue + [0] [0 0] [0] >= [1 0] @futurequeue + [0] [0 0] [0] = [c_3(bfs#2^#(@futurequeue, @x))] [bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1 0] @futurequeue + [1 0] @ts + [0] [0 0] [0 0] [0] >= [1 0] @futurequeue + [1 0] @ts + [0] [0 0] [0 0] [0] = [c_4(bfs^#(@ts, @futurequeue, @x))] [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1 0] @futurequeue + [1 0] @t1 + [1 0] @t2 + [1 0] @ts + [2] [0 0] [0 0] [0 0] [0 0] [0] >= [1 0] @futurequeue + [1 0] @t1 + [1 0] @t2 + [1 0] @ts + [2] [0 0] [0 0] [0 0] [0 0] [0] = [c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))] [bfs#2^#(::(@t, @ts), @x)] = [1 0] @t + [1 0] @ts + [1] [0 0] [0 0] [0] >= [1 0] @t + [1 0] @ts + [1] [0 0] [0 0] [0] = [c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))] [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1 0] @futurequeue + [1 0] @t1 + [1 0] @t2 + [1 0] @ts + [2] [0 0] [0 0] [0 0] [0 0] [0] >= [1 0] @futurequeue + [1 0] @t1 + [1 0] @t2 + [1 0] @ts + [2] [0 0] [0 0] [0 0] [0 0] [0] = [c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))] [bfs2^#(@t, @x)] = [2 0] @t + [1 0] @x + [2] [1 1] [2 2] [1] >= [2 0] @t + [2] [0 0] [0] = [c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))] [bfs2#1^#(@t', @x)] = [1 0] @t' + [1] [0 0] [0] >= [1 0] @t' + [1] [0 0] [0] = [c_9(dobfs^#(@t', @x))] [dobfs^#(@t, @x)] = [1 0] @t + [1] [0 2] [0] >= [1 0] @t + [1] [0 0] [0] = [c_10(bfs^#(::(@t, nil()), nil(), @x))] Consider the set of all dependency pairs DPs: { 1: bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , 2: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , 3: bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , 4: bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , 5: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , 6: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , 8: bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , 9: bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2}. These cover all (indirect) predecessors of dependency pairs {2,5,6,7,8,9,10}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) } Weak DPs: { bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 3: bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Trs: { #eq(nil(), nil()) -> #true() , #eq(leaf(), leaf()) -> #true() , #eq(#0(), #0()) -> #true() , #and(#true(), #true()) -> #true() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1}, Uargs(c_10) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#equal](x1, x2) = [0 1] x2 + [2] [1 0] [2] [#eq](x1, x2) = [2] [2] [appendreverse](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [appendreverse#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [::](x1, x2) = [0 0] x1 + [1 0] x2 + [1] [1 1] [0 1] [0] [nil] = [0] [0] [bfs](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [0] [0 1] [0 1] [0] [bfs#1](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [0] [0 1] [0 1] [0] [bfs#3](x1, x2, x3, x4) = [0 0] x1 + [0 0] x2 + [0 0] x3 + [0] [0 1] [0 1] [0 1] [0] [bfs#2](x1, x2) = [0 0] x1 + [0] [0 1] [0] [reverse](x1) = [1 0] x1 + [0] [0 1] [0] [leaf] = [0] [0] [node](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [0 0] x3 + [0] [1 1] [1 1] [1 1] [2] [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [0 0] x2 + [0 0] x3 + [0 0] x4 + [0 0] x5 + [0 0] x7 + [0] [0 1] [1 1] [1 1] [0 1] [1 1] [2] [#false] = [2] [2] [#true] = [0] [2] [dobfs](x1, x2) = [0 0] x1 + [0] [1 1] [0] [#and](x1, x2) = [0 1] x2 + [0] [0 0] [2] [#0] = [2] [2] [#neg](x1) = [1 0] x1 + [0] [0 1] [2] [#pos](x1) = [1 0] x1 + [0] [0 1] [2] [#s](x1) = [1 0] x1 + [0] [0 1] [2] [#equal^#](x1, x2) = [0] [0] [#eq^#](x1, x2) = [0] [0] [appendreverse^#](x1, x2) = [0] [0] [appendreverse#1^#](x1, x2) = [0] [0] [bfs^#](x1, x2, x3) = [0 1] x1 + [1 1] x2 + [0] [0 0] [0 1] [0] [bfs#1^#](x1, x2, x3) = [0 1] x1 + [1 1] x2 + [0] [0 0] [0 0] [0] [bfs#3^#](x1, x2, x3, x4) = [1 1] x1 + [1 1] x2 + [0 1] x3 + [0] [0 0] [0 0] [0 1] [0] [bfs#2^#](x1, x2) = [1 1] x1 + [0] [0 0] [0] [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [1 1] x4 + [0 1] x5 + [1 0] x7 + [0] [0 0] [0 0] [0 0] [1 1] [0 0] [0 0] [0] [reverse^#](x1) = [0] [0] [bfs2^#](x1, x2) = [2 2] x1 + [2 2] x2 + [2] [2 1] [1 1] [1] [bfs2#1^#](x1, x2) = [2 1] x1 + [0 0] x2 + [1] [0 0] [1 2] [0] [dobfs^#](x1, x2) = [1 1] x1 + [1] [0 1] [1] [dfs^#](x1, x2) = [0] [0] [dfs#1^#](x1, x2) = [0] [0] [dfs#2^#](x1, x2, x3, x4) = [0] [0] [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0] [0] [dodfs^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1, x2) = [0] [0] [c_9](x1) = [0] [0] [c_11](x1, x2) = [0] [0] [c_12](x1) = [0] [0] [c_13](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1) = [1 0] x1 + [0] [0 0] [0] [c_3](x1) = [1 0] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_5](x1) = [1 0] x1 + [0] [0 0] [0] [c_6](x1) = [1 1] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1, x2) = [1 1] x1 + [1 0] x2 + [0] [0 0] [0 0] [0] [c_9](x1) = [1 0] x1 + [0] [0 0] [0] [c_10](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [#equal(@x, @y)] = [0 1] @y + [2] [1 0] [2] >= [2] [2] = [#eq(@x, @y)] [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [2] [2] >= [2] [2] = [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))] [#eq(::(@x_1, @x_2), nil())] = [2] [2] >= [2] [2] = [#false()] [#eq(::(@x_1, @x_2), leaf())] = [2] [2] >= [2] [2] = [#false()] [#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [2] [2] >= [2] [2] = [#false()] [#eq(nil(), ::(@y_1, @y_2))] = [2] [2] >= [2] [2] = [#false()] [#eq(nil(), nil())] = [2] [2] > [0] [2] = [#true()] [#eq(nil(), leaf())] = [2] [2] >= [2] [2] = [#false()] [#eq(nil(), node(@y_1, @y_2, @y_3))] = [2] [2] >= [2] [2] = [#false()] [#eq(leaf(), ::(@y_1, @y_2))] = [2] [2] >= [2] [2] = [#false()] [#eq(leaf(), nil())] = [2] [2] >= [2] [2] = [#false()] [#eq(leaf(), leaf())] = [2] [2] > [0] [2] = [#true()] [#eq(leaf(), node(@y_1, @y_2, @y_3))] = [2] [2] >= [2] [2] = [#false()] [#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [2] [2] >= [2] [2] = [#false()] [#eq(node(@x_1, @x_2, @x_3), nil())] = [2] [2] >= [2] [2] = [#false()] [#eq(node(@x_1, @x_2, @x_3), leaf())] = [2] [2] >= [2] [2] = [#false()] [#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [2] [2] >= [2] [2] = [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))] [#eq(#0(), #0())] = [2] [2] > [0] [2] = [#true()] [#eq(#0(), #neg(@y))] = [2] [2] >= [2] [2] = [#false()] [#eq(#0(), #pos(@y))] = [2] [2] >= [2] [2] = [#false()] [#eq(#0(), #s(@y))] = [2] [2] >= [2] [2] = [#false()] [#eq(#neg(@x), #0())] = [2] [2] >= [2] [2] = [#false()] [#eq(#neg(@x), #neg(@y))] = [2] [2] >= [2] [2] = [#eq(@x, @y)] [#eq(#neg(@x), #pos(@y))] = [2] [2] >= [2] [2] = [#false()] [#eq(#pos(@x), #0())] = [2] [2] >= [2] [2] = [#false()] [#eq(#pos(@x), #neg(@y))] = [2] [2] >= [2] [2] = [#false()] [#eq(#pos(@x), #pos(@y))] = [2] [2] >= [2] [2] = [#eq(@x, @y)] [#eq(#s(@x), #0())] = [2] [2] >= [2] [2] = [#false()] [#eq(#s(@x), #s(@y))] = [2] [2] >= [2] [2] = [#eq(@x, @y)] [appendreverse(@toreverse, @sofar)] = [1 0] @sofar + [1 0] @toreverse + [0] [0 1] [0 1] [0] >= [1 0] @sofar + [1 0] @toreverse + [0] [0 1] [0 1] [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [0 0] @a + [1 0] @as + [1 0] @sofar + [1] [1 1] [0 1] [0 1] [0] >= [0 0] @a + [1 0] @as + [1 0] @sofar + [1] [1 1] [0 1] [0 1] [0] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1 0] @sofar + [0] [0 1] [0] >= [1 0] @sofar + [0] [0 1] [0] = [@sofar] [bfs(@queue, @futurequeue, @x)] = [0 0] @futurequeue + [0 0] @queue + [0] [0 1] [0 1] [0] >= [0 0] @futurequeue + [0 0] @queue + [0] [0 1] [0 1] [0] = [bfs#1(@queue, @futurequeue, @x)] [bfs#1(::(@t, @ts), @futurequeue, @x)] = [0 0] @futurequeue + [0 0] @t + [0 0] @ts + [0] [0 1] [1 1] [0 1] [0] >= [0 0] @futurequeue + [0 0] @t + [0 0] @ts + [0] [0 1] [0 1] [0 1] [0] = [bfs#3(@t, @futurequeue, @ts, @x)] [bfs#1(nil(), @futurequeue, @x)] = [0 0] @futurequeue + [0] [0 1] [0] >= [0 0] @futurequeue + [0] [0 1] [0] = [bfs#2(@futurequeue, @x)] [bfs#3(leaf(), @futurequeue, @ts, @x)] = [0 0] @futurequeue + [0 0] @ts + [0] [0 1] [0 1] [0] >= [0 0] @futurequeue + [0 0] @ts + [0] [0 1] [0 1] [0] = [bfs(@ts, @futurequeue, @x)] [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0 0] @y + [0] [0 1] [1 1] [1 1] [0 1] [1 1] [2] >= [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0 0] @y + [0] [0 1] [1 1] [1 1] [0 1] [1 1] [2] = [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)] [bfs#2(::(@t, @ts), @x)] = [0 0] @t + [0 0] @ts + [0] [1 1] [0 1] [0] >= [0 0] @t + [0 0] @ts + [0] [1 1] [0 1] [0] = [bfs(reverse(::(@t, @ts)), nil(), @x)] [bfs#2(nil(), @x)] = [0] [0] >= [0] [0] = [leaf()] [reverse(@xs)] = [1 0] @xs + [0] [0 1] [0] >= [1 0] @xs + [0] [0 1] [0] = [appendreverse(@xs, nil())] [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0 0] @y + [0] [0 1] [1 1] [1 1] [0 1] [1 1] [2] >= [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0] [0 1] [1 1] [1 1] [0 1] [0] = [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)] [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0 0] @y + [0] [0 1] [1 1] [1 1] [0 1] [1 1] [2] >= [0 0] @t1 + [0 0] @t2 + [0 0] @y + [0] [1 1] [1 1] [1 1] [2] = [node(@y, @t1, @t2)] [dobfs(@t, @x)] = [0 0] @t + [0] [1 1] [0] >= [0 0] @t + [0] [1 1] [0] = [bfs(::(@t, nil()), nil(), @x)] [#and(#false(), #false())] = [2] [2] >= [2] [2] = [#false()] [#and(#false(), #true())] = [2] [2] >= [2] [2] = [#false()] [#and(#true(), #false())] = [2] [2] >= [2] [2] = [#false()] [#and(#true(), #true())] = [2] [2] > [0] [2] = [#true()] [bfs^#(@queue, @futurequeue, @x)] = [1 1] @futurequeue + [0 1] @queue + [0] [0 1] [0 0] [0] >= [1 1] @futurequeue + [0 1] @queue + [0] [0 0] [0 0] [0] = [c_1(bfs#1^#(@queue, @futurequeue, @x))] [bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1 1] @futurequeue + [1 1] @t + [0 1] @ts + [0] [0 0] [0 0] [0 0] [0] >= [1 1] @futurequeue + [1 1] @t + [0 1] @ts + [0] [0 0] [0 0] [0 0] [0] = [c_2(bfs#3^#(@t, @futurequeue, @ts, @x))] [bfs#1^#(nil(), @futurequeue, @x)] = [1 1] @futurequeue + [0] [0 0] [0] >= [1 1] @futurequeue + [0] [0 0] [0] = [c_3(bfs#2^#(@futurequeue, @x))] [bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1 1] @futurequeue + [0 1] @ts + [0] [0 0] [0 1] [0] >= [1 1] @futurequeue + [0 1] @ts + [0] [0 0] [0 0] [0] = [c_4(bfs^#(@ts, @futurequeue, @x))] [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1 1] @y + [2] [0 0] [0 0] [0 0] [0 1] [0 0] [0] >= [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1 1] @y + [2] [0 0] [0 0] [0 0] [0 0] [0 0] [0] = [c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))] [bfs#2^#(::(@t, @ts), @x)] = [1 1] @t + [1 1] @ts + [1] [0 0] [0 0] [0] > [1 1] @t + [0 1] @ts + [0] [0 0] [0 0] [0] = [c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))] [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1 0] @y + [2] [0 0] [0 0] [1 1] [0 0] [0 0] [0] >= [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [2] [0 0] [0 0] [0 0] [0 0] [0] = [c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))] [bfs2^#(@t, @x)] = [2 2] @t + [2 2] @x + [2] [2 1] [1 1] [1] >= [2 2] @t + [1 2] @x + [2] [0 0] [0 0] [0] = [c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))] [bfs2#1^#(@t', @x)] = [2 1] @t' + [0 0] @x + [1] [0 0] [1 2] [0] >= [1 1] @t' + [1] [0 0] [0] = [c_9(dobfs^#(@t', @x))] [dobfs^#(@t, @x)] = [1 1] @t + [1] [0 1] [1] > [1 1] @t + [0] [0 0] [0] = [c_10(bfs^#(::(@t, nil()), nil(), @x))] Consider the set of all dependency pairs DPs: { 1: bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , 2: bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , 3: bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , 4: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , 5: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , 6: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , 8: bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , 9: bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {3,10}. These cover all (indirect) predecessors of dependency pairs {3,8,9,10}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) } Weak DPs: { bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 4: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , 6: bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) } Trs: { #eq(nil(), nil()) -> #true() , #eq(leaf(), leaf()) -> #true() , #eq(#0(), #0()) -> #true() , appendreverse#1(nil(), @sofar) -> @sofar , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , #and(#true(), #true()) -> #true() } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1}, Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1}, Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1}, Uargs(c_10) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#equal](x1, x2) = [1] [1] [#eq](x1, x2) = [1] [1] [appendreverse](x1, x2) = [2 0] x1 + [2 0] x2 + [2] [0 1] [0 1] [0] [appendreverse#1](x1, x2) = [2 0] x1 + [2 0] x2 + [2] [0 1] [0 1] [0] [::](x1, x2) = [0 0] x1 + [1 0] x2 + [1] [1 1] [0 1] [0] [nil] = [0] [0] [bfs](x1, x2, x3) = [0 1] x1 + [0 1] x2 + [1] [0 0] [0 0] [1] [bfs#1](x1, x2, x3) = [0 1] x1 + [0 1] x2 + [1] [0 0] [0 0] [1] [bfs#3](x1, x2, x3, x4) = [1 1] x1 + [0 1] x2 + [0 1] x3 + [1] [0 0] [0 0] [0 0] [1] [bfs#2](x1, x2) = [0 1] x1 + [1] [0 0] [1] [reverse](x1) = [2 0] x1 + [2] [0 1] [0] [leaf] = [1] [0] [node](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1 1] x3 + [2] [0 0] [0 0] [0 0] [1] [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1 2] x1 + [0 1] x2 + [1 1] x3 + [1 1] x4 + [0 1] x5 + [1 0] x7 + [0] [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [1] [#false] = [1] [1] [#true] = [0] [1] [dobfs](x1, x2) = [1 1] x1 + [1] [0 0] [1] [#and](x1, x2) = [0 1] x1 + [0] [0 1] [0] [#0] = [0] [0] [#neg](x1) = [1 0] x1 + [0] [0 1] [0] [#pos](x1) = [1 0] x1 + [1] [0 1] [0] [#s](x1) = [1 0] x1 + [0] [0 1] [0] [#equal^#](x1, x2) = [0] [0] [#eq^#](x1, x2) = [0] [0] [appendreverse^#](x1, x2) = [0] [0] [appendreverse#1^#](x1, x2) = [0] [0] [bfs^#](x1, x2, x3) = [0 1] x1 + [1 1] x2 + [0] [1 0] [0 0] [0] [bfs#1^#](x1, x2, x3) = [0 1] x1 + [1 1] x2 + [0] [0 0] [0 0] [0] [bfs#3^#](x1, x2, x3, x4) = [1 1] x1 + [1 1] x2 + [0 1] x3 + [0] [0 0] [0 0] [0 0] [0] [bfs#2^#](x1, x2) = [1 1] x1 + [0] [0 0] [0] [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1 1] x1 + [1 1] x2 + [1 1] x3 + [1 1] x4 + [0 1] x5 + [1] [0 0] [0 0] [0 0] [0 0] [0 0] [0] [reverse^#](x1) = [0] [0] [bfs2^#](x1, x2) = [2 2] x1 + [2 2] x2 + [2] [1 2] [1 1] [2] [bfs2#1^#](x1, x2) = [1 1] x1 + [0 2] x2 + [0] [0 0] [0 0] [0] [dobfs^#](x1, x2) = [1 1] x1 + [0 0] x2 + [0] [0 0] [2 0] [0] [dfs^#](x1, x2) = [0] [0] [dfs#1^#](x1, x2) = [0] [0] [dfs#2^#](x1, x2, x3, x4) = [0] [0] [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0] [0] [dodfs^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [c_3](x1) = [0] [0] [c_4](x1) = [0] [0] [c_5](x1) = [0] [0] [c_6](x1) = [0] [0] [c_7](x1) = [0] [0] [c_8](x1, x2) = [0] [0] [c_9](x1) = [0] [0] [c_11](x1, x2) = [0] [0] [c_12](x1) = [0] [0] [c_13](x1) = [0] [0] [c] = [0] [0] [c_1](x1) = [1 0] x1 + [0] [0 0] [0] [c_2](x1) = [1 0] x1 + [0] [0 0] [0] [c_3](x1) = [1 0] x1 + [0] [0 0] [0] [c_4](x1) = [1 0] x1 + [0] [0 0] [0] [c_5](x1) = [1 1] x1 + [0] [0 0] [0] [c_6](x1) = [1 0] x1 + [0] [0 0] [0] [c_7](x1) = [1 0] x1 + [0] [0 0] [0] [c_8](x1, x2) = [1 0] x1 + [1 1] x2 + [0] [0 0] [0 0] [0] [c_9](x1) = [1 0] x1 + [0] [0 0] [0] [c_10](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [#equal(@x, @y)] = [1] [1] >= [1] [1] = [#eq(@x, @y)] [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [1] [1] >= [1] [1] = [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))] [#eq(::(@x_1, @x_2), nil())] = [1] [1] >= [1] [1] = [#false()] [#eq(::(@x_1, @x_2), leaf())] = [1] [1] >= [1] [1] = [#false()] [#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [1] [1] >= [1] [1] = [#false()] [#eq(nil(), ::(@y_1, @y_2))] = [1] [1] >= [1] [1] = [#false()] [#eq(nil(), nil())] = [1] [1] > [0] [1] = [#true()] [#eq(nil(), leaf())] = [1] [1] >= [1] [1] = [#false()] [#eq(nil(), node(@y_1, @y_2, @y_3))] = [1] [1] >= [1] [1] = [#false()] [#eq(leaf(), ::(@y_1, @y_2))] = [1] [1] >= [1] [1] = [#false()] [#eq(leaf(), nil())] = [1] [1] >= [1] [1] = [#false()] [#eq(leaf(), leaf())] = [1] [1] > [0] [1] = [#true()] [#eq(leaf(), node(@y_1, @y_2, @y_3))] = [1] [1] >= [1] [1] = [#false()] [#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [1] [1] >= [1] [1] = [#false()] [#eq(node(@x_1, @x_2, @x_3), nil())] = [1] [1] >= [1] [1] = [#false()] [#eq(node(@x_1, @x_2, @x_3), leaf())] = [1] [1] >= [1] [1] = [#false()] [#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [1] [1] >= [1] [1] = [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))] [#eq(#0(), #0())] = [1] [1] > [0] [1] = [#true()] [#eq(#0(), #neg(@y))] = [1] [1] >= [1] [1] = [#false()] [#eq(#0(), #pos(@y))] = [1] [1] >= [1] [1] = [#false()] [#eq(#0(), #s(@y))] = [1] [1] >= [1] [1] = [#false()] [#eq(#neg(@x), #0())] = [1] [1] >= [1] [1] = [#false()] [#eq(#neg(@x), #neg(@y))] = [1] [1] >= [1] [1] = [#eq(@x, @y)] [#eq(#neg(@x), #pos(@y))] = [1] [1] >= [1] [1] = [#false()] [#eq(#pos(@x), #0())] = [1] [1] >= [1] [1] = [#false()] [#eq(#pos(@x), #neg(@y))] = [1] [1] >= [1] [1] = [#false()] [#eq(#pos(@x), #pos(@y))] = [1] [1] >= [1] [1] = [#eq(@x, @y)] [#eq(#s(@x), #0())] = [1] [1] >= [1] [1] = [#false()] [#eq(#s(@x), #s(@y))] = [1] [1] >= [1] [1] = [#eq(@x, @y)] [appendreverse(@toreverse, @sofar)] = [2 0] @sofar + [2 0] @toreverse + [2] [0 1] [0 1] [0] >= [2 0] @sofar + [2 0] @toreverse + [2] [0 1] [0 1] [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [0 0] @a + [2 0] @as + [2 0] @sofar + [4] [1 1] [0 1] [0 1] [0] >= [0 0] @a + [2 0] @as + [2 0] @sofar + [4] [1 1] [0 1] [0 1] [0] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [2 0] @sofar + [2] [0 1] [0] > [1 0] @sofar + [0] [0 1] [0] = [@sofar] [bfs(@queue, @futurequeue, @x)] = [0 1] @futurequeue + [0 1] @queue + [1] [0 0] [0 0] [1] >= [0 1] @futurequeue + [0 1] @queue + [1] [0 0] [0 0] [1] = [bfs#1(@queue, @futurequeue, @x)] [bfs#1(::(@t, @ts), @futurequeue, @x)] = [0 1] @futurequeue + [1 1] @t + [0 1] @ts + [1] [0 0] [0 0] [0 0] [1] >= [0 1] @futurequeue + [1 1] @t + [0 1] @ts + [1] [0 0] [0 0] [0 0] [1] = [bfs#3(@t, @futurequeue, @ts, @x)] [bfs#1(nil(), @futurequeue, @x)] = [0 1] @futurequeue + [1] [0 0] [1] >= [0 1] @futurequeue + [1] [0 0] [1] = [bfs#2(@futurequeue, @x)] [bfs#3(leaf(), @futurequeue, @ts, @x)] = [0 1] @futurequeue + [0 1] @ts + [2] [0 0] [0 0] [1] > [0 1] @futurequeue + [0 1] @ts + [1] [0 0] [0 0] [1] = [bfs(@ts, @futurequeue, @x)] [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [0 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1 0] @y + [4] [0 0] [0 0] [0 0] [0 0] [0 0] [1] > [0 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1 0] @y + [3] [0 0] [0 0] [0 0] [0 0] [0 0] [1] = [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)] [bfs#2(::(@t, @ts), @x)] = [1 1] @t + [0 1] @ts + [1] [0 0] [0 0] [1] >= [1 1] @t + [0 1] @ts + [1] [0 0] [0 0] [1] = [bfs(reverse(::(@t, @ts)), nil(), @x)] [bfs#2(nil(), @x)] = [1] [1] >= [1] [0] = [leaf()] [reverse(@xs)] = [2 0] @xs + [2] [0 1] [0] >= [2 0] @xs + [2] [0 1] [0] = [appendreverse(@xs, nil())] [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [0 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1 0] @y + [3] [0 0] [0 0] [0 0] [0 0] [0 0] [1] > [0 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1] [0 0] [0 0] [0 0] [0 0] [1] = [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)] [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [0 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1 0] @y + [2] [0 0] [0 0] [0 0] [0 0] [0 0] [1] >= [1 1] @t1 + [1 1] @t2 + [1 0] @y + [2] [0 0] [0 0] [0 0] [1] = [node(@y, @t1, @t2)] [dobfs(@t, @x)] = [1 1] @t + [1] [0 0] [1] >= [1 1] @t + [1] [0 0] [1] = [bfs(::(@t, nil()), nil(), @x)] [#and(#false(), #false())] = [1] [1] >= [1] [1] = [#false()] [#and(#false(), #true())] = [1] [1] >= [1] [1] = [#false()] [#and(#true(), #false())] = [1] [1] >= [1] [1] = [#false()] [#and(#true(), #true())] = [1] [1] > [0] [1] = [#true()] [bfs^#(@queue, @futurequeue, @x)] = [1 1] @futurequeue + [0 1] @queue + [0] [0 0] [1 0] [0] >= [1 1] @futurequeue + [0 1] @queue + [0] [0 0] [0 0] [0] = [c_1(bfs#1^#(@queue, @futurequeue, @x))] [bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1 1] @futurequeue + [1 1] @t + [0 1] @ts + [0] [0 0] [0 0] [0 0] [0] >= [1 1] @futurequeue + [1 1] @t + [0 1] @ts + [0] [0 0] [0 0] [0 0] [0] = [c_2(bfs#3^#(@t, @futurequeue, @ts, @x))] [bfs#1^#(nil(), @futurequeue, @x)] = [1 1] @futurequeue + [0] [0 0] [0] >= [1 1] @futurequeue + [0] [0 0] [0] = [c_3(bfs#2^#(@futurequeue, @x))] [bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1 1] @futurequeue + [0 1] @ts + [1] [0 0] [0 0] [0] > [1 1] @futurequeue + [0 1] @ts + [0] [0 0] [0 0] [0] = [c_4(bfs^#(@ts, @futurequeue, @x))] [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1 0] @y + [3] [0 0] [0 0] [0 0] [0 0] [0 0] [0] >= [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [3] [0 0] [0 0] [0 0] [0 0] [0] = [c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))] [bfs#2^#(::(@t, @ts), @x)] = [1 1] @t + [1 1] @ts + [1] [0 0] [0 0] [0] > [1 1] @t + [0 1] @ts + [0] [0 0] [0 0] [0] = [c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))] [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [3] [0 0] [0 0] [0 0] [0 0] [0] > [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [2] [0 0] [0 0] [0 0] [0 0] [0] = [c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))] [bfs2^#(@t, @x)] = [2 2] @t + [2 2] @x + [2] [1 2] [1 1] [2] >= [2 2] @t + [2 2] @x + [2] [0 0] [0 0] [0] = [c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))] [bfs2#1^#(@t', @x)] = [1 1] @t' + [0 2] @x + [0] [0 0] [0 0] [0] >= [1 1] @t' + [0] [0 0] [0] = [c_9(dobfs^#(@t', @x))] [dobfs^#(@t, @x)] = [1 1] @t + [0 0] @x + [0] [0 0] [2 0] [0] >= [1 1] @t + [0] [0 0] [0] = [c_10(bfs^#(::(@t, nil()), nil(), @x))] Consider the set of all dependency pairs DPs: { 1: bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , 2: bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , 3: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , 4: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , 5: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , 6: bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , 8: bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , 9: bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {4,6,7}. These cover all (indirect) predecessors of dependency pairs {1,2,3,4,5,6,7,8,9,10}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { bfs^#(@queue, @futurequeue, @x) -> c_1(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_3(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_4(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , bfs2^#(@t, @x) -> c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded We return to the main proof. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) } Weak DPs: { bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> bfs#3^#(@t, @futurequeue, @ts, @x) , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2^#(::(@t, @ts), @x) -> bfs^#(reverse(::(@t, @ts)), nil(), @x) , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x) , bfs2^#(@t, @x) -> dobfs^#(@t, @x) , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) Consider the dependency graph 1: appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) -->_1 appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) :2 2: appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) -->_1 appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) :1 3: reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) -->_1 appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) :1 4: bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) -->_1 bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) :6 -->_1 bfs#1^#(::(@t, @ts), @futurequeue, @x) -> bfs#3^#(@t, @futurequeue, @ts, @x) :5 5: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> bfs#3^#(@t, @futurequeue, @ts, @x) -->_1 bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) :8 -->_1 bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) :7 6: bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) -->_1 bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) :10 -->_1 bfs#2^#(::(@t, @ts), @x) -> bfs^#(reverse(::(@t, @ts)), nil(), @x) :9 7: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) -->_1 bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) :4 8: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) -->_1 bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) :11 9: bfs#2^#(::(@t, @ts), @x) -> bfs^#(reverse(::(@t, @ts)), nil(), @x) -->_1 bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) :4 10: bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) -->_1 reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) :3 11: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) -->_1 bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) :4 12: bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x) -->_1 bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) :14 13: bfs2^#(@t, @x) -> dobfs^#(@t, @x) -->_1 dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) :15 14: bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) -->_1 dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) :15 15: dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) -->_1 bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) :4 Following roots of the dependency graph are removed, as the considered set of starting terms is closed under reduction with respect to these rules (modulo compound contexts). { bfs2^#(@t, @x) -> dobfs^#(@t, @x) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) } Weak DPs: { bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> bfs#3^#(@t, @futurequeue, @ts, @x) , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2^#(::(@t, @ts), @x) -> bfs^#(reverse(::(@t, @ts)), nil(), @x) , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x) , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 2: appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , 7: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) } Trs: { bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_10) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#equal](x1, x2) = [0] [#eq](x1, x2) = [0] [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0] [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [1] [nil] = [0] [bfs](x1, x2, x3) = [1] x1 + [1] x2 + [0] [bfs#1](x1, x2, x3) = [1] x1 + [1] x2 + [0] [bfs#3](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1] [bfs#2](x1, x2) = [1] x1 + [0] [reverse](x1) = [1] x1 + [0] [leaf] = [0] [node](x1, x2, x3) = [1] x2 + [1] x3 + [1] [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [2] [#false] = [0] [#true] = [0] [dobfs](x1, x2) = [1] x1 + [1] [#and](x1, x2) = [0] [#0] = [0] [#neg](x1) = [1] x1 + [0] [#pos](x1) = [1] x1 + [0] [#s](x1) = [1] x1 + [0] [#equal^#](x1, x2) = [0] [#eq^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [1] x1 + [0] [appendreverse#1^#](x1, x2) = [1] x1 + [0] [bfs^#](x1, x2, x3) = [1] x1 + [1] x2 + [0] [bfs#1^#](x1, x2, x3) = [1] x1 + [1] x2 + [0] [bfs#3^#](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1] [bfs#2^#](x1, x2) = [1] x1 + [0] [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [2] [reverse^#](x1) = [1] x1 + [0] [bfs2^#](x1, x2) = [2] x1 + [2] x2 + [2] [bfs2#1^#](x1, x2) = [1] x1 + [1] [dobfs^#](x1, x2) = [1] x1 + [1] [dfs^#](x1, x2) = [0] [dfs#1^#](x1, x2) = [0] [dfs#2^#](x1, x2, x3, x4) = [0] [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0] [dodfs^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [c_1](x1) = [1] x1 + [0] [c_2](x1) = [1] x1 + [0] [c_10](x1) = [1] x1 + [0] This order satisfies following ordering constraints [appendreverse(@toreverse, @sofar)] = [1] @sofar + [1] @toreverse + [0] >= [1] @sofar + [1] @toreverse + [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] @sofar + [1] >= [1] @a + [1] @as + [1] @sofar + [1] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1] @sofar + [0] >= [1] @sofar + [0] = [@sofar] [bfs(@queue, @futurequeue, @x)] = [1] @futurequeue + [1] @queue + [0] >= [1] @futurequeue + [1] @queue + [0] = [bfs#1(@queue, @futurequeue, @x)] [bfs#1(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [1] >= [1] @futurequeue + [1] @t + [1] @ts + [1] = [bfs#3(@t, @futurequeue, @ts, @x)] [bfs#1(nil(), @futurequeue, @x)] = [1] @futurequeue + [0] >= [1] @futurequeue + [0] = [bfs#2(@futurequeue, @x)] [bfs#3(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] > [1] @futurequeue + [1] @ts + [0] = [bfs(@ts, @futurequeue, @x)] [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2] >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2] = [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)] [bfs#2(::(@t, @ts), @x)] = [1] @t + [1] @ts + [1] >= [1] @t + [1] @ts + [1] = [bfs(reverse(::(@t, @ts)), nil(), @x)] [bfs#2(nil(), @x)] = [0] >= [0] = [leaf()] [reverse(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [appendreverse(@xs, nil())] [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2] >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2] = [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)] [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2] > [1] @t1 + [1] @t2 + [1] = [node(@y, @t1, @t2)] [dobfs(@t, @x)] = [1] @t + [1] >= [1] @t + [1] = [bfs(::(@t, nil()), nil(), @x)] [appendreverse^#(@toreverse, @sofar)] = [1] @toreverse + [0] >= [1] @toreverse + [0] = [c_1(appendreverse#1^#(@toreverse, @sofar))] [appendreverse#1^#(::(@a, @as), @sofar)] = [1] @a + [1] @as + [1] > [1] @as + [0] = [c_2(appendreverse^#(@as, ::(@a, @sofar)))] [bfs^#(@queue, @futurequeue, @x)] = [1] @futurequeue + [1] @queue + [0] >= [1] @futurequeue + [1] @queue + [0] = [bfs#1^#(@queue, @futurequeue, @x)] [bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1] @futurequeue + [1] @t + [1] @ts + [1] >= [1] @futurequeue + [1] @t + [1] @ts + [1] = [bfs#3^#(@t, @futurequeue, @ts, @x)] [bfs#1^#(nil(), @futurequeue, @x)] = [1] @futurequeue + [0] >= [1] @futurequeue + [0] = [bfs#2^#(@futurequeue, @x)] [bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @ts + [1] > [1] @futurequeue + [1] @ts + [0] = [bfs^#(@ts, @futurequeue, @x)] [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2] >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2] = [bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)] [bfs#2^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [1] >= [1] @t + [1] @ts + [1] = [bfs^#(reverse(::(@t, @ts)), nil(), @x)] [bfs#2^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [1] >= [1] @t + [1] @ts + [1] = [reverse^#(::(@t, @ts))] [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2] >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2] = [bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)] [reverse^#(@xs)] = [1] @xs + [0] >= [1] @xs + [0] = [c_10(appendreverse^#(@xs, nil()))] [bfs2^#(@t, @x)] = [2] @t + [2] @x + [2] >= [1] @t + [2] = [bfs2#1^#(dobfs(@t, @x), @x)] [bfs2#1^#(@t', @x)] = [1] @t' + [1] >= [1] @t' + [1] = [dobfs^#(@t', @x)] [dobfs^#(@t, @x)] = [1] @t + [1] >= [1] @t + [1] = [bfs^#(::(@t, nil()), nil(), @x)] Consider the set of all dependency pairs DPs: { 1: appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , 2: appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , 3: reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , 4: bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) , 5: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> bfs#3^#(@t, @futurequeue, @ts, @x) , 6: bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) , 7: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) , 8: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , 9: bfs#2^#(::(@t, @ts), @x) -> bfs^#(reverse(::(@t, @ts)), nil(), @x) , 10: bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) , 11: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , 12: bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x) , 13: bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) , 14: dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {2,7}. These cover all (indirect) predecessors of dependency pairs {2,7,12,13,14}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) } Weak DPs: { appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> bfs#3^#(@t, @futurequeue, @ts, @x) , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2^#(::(@t, @ts), @x) -> bfs^#(reverse(::(@t, @ts)), nil(), @x) , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x) , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 2' to orient following rules strictly. DPs: { 3: appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , 6: bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) } Trs: { appendreverse#1(nil(), @sofar) -> @sofar , bfs#2(nil(), @x) -> leaf() , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_10) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA) and not(IDA(1)). [#equal](x1, x2) = [0 0] x2 + [0] [1 0] [1] [#eq](x1, x2) = [0 0] x2 + [0] [1 0] [1] [appendreverse](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [appendreverse#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0] [0 1] [0 1] [0] [::](x1, x2) = [0 0] x1 + [1 0] x2 + [2] [0 1] [0 1] [0] [nil] = [1] [0] [bfs](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [2] [0 1] [0 1] [0] [bfs#1](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [2] [0 1] [0 1] [0] [bfs#3](x1, x2, x3, x4) = [0 0] x1 + [0 0] x2 + [0 0] x3 + [2] [0 1] [0 1] [0 1] [0] [bfs#2](x1, x2) = [0 0] x1 + [2] [0 1] [0] [reverse](x1) = [2 0] x1 + [1] [0 1] [0] [leaf] = [1] [0] [node](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [0 0] x3 + [1] [1 0] [1 1] [1 1] [1] [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [0 0] x2 + [0 0] x3 + [0 0] x4 + [0 0] x5 + [0 0] x7 + [2] [0 1] [1 1] [1 1] [0 1] [1 0] [1] [#false] = [0] [2] [#true] = [0] [0] [dobfs](x1, x2) = [0 0] x1 + [2] [1 1] [0] [#and](x1, x2) = [0] [2] [#0] = [1] [0] [#neg](x1) = [1 1] x1 + [2] [0 0] [0] [#pos](x1) = [1 1] x1 + [1] [0 0] [0] [#s](x1) = [1 1] x1 + [2] [0 0] [0] [#equal^#](x1, x2) = [0] [0] [#eq^#](x1, x2) = [0] [0] [appendreverse^#](x1, x2) = [1 0] x1 + [0] [0 0] [1] [appendreverse#1^#](x1, x2) = [1 0] x1 + [0] [0 0] [0] [bfs^#](x1, x2, x3) = [0 2] x1 + [1 2] x2 + [2 2] x3 + [1] [0 0] [0 0] [0 0] [0] [bfs#1^#](x1, x2, x3) = [0 2] x1 + [1 2] x2 + [2 2] x3 + [1] [0 0] [0 0] [0 0] [0] [bfs#3^#](x1, x2, x3, x4) = [0 2] x1 + [1 2] x2 + [0 2] x3 + [2 2] x4 + [1] [0 0] [0 0] [0 0] [0 0] [0] [bfs#2^#](x1, x2) = [1 2] x1 + [2 2] x2 + [0] [0 0] [0 0] [0] [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [2 2] x1 + [1 2] x2 + [0 2] x3 + [0 2] x4 + [0 2] x5 + [2 2] x6 + [1] [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [0] [reverse^#](x1) = [1 2] x1 + [0] [0 0] [0] [bfs2^#](x1, x2) = [2 2] x1 + [2 2] x2 + [2] [2 1] [1 1] [1] [bfs2#1^#](x1, x2) = [0 2] x1 + [2 2] x2 + [2] [0 0] [0 0] [0] [dobfs^#](x1, x2) = [0 2] x1 + [2 2] x2 + [2] [0 0] [0 0] [0] [dfs^#](x1, x2) = [0] [0] [dfs#1^#](x1, x2) = [0] [0] [dfs#2^#](x1, x2, x3, x4) = [0] [0] [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0] [0] [dodfs^#](x1, x2) = [0] [0] [#and^#](x1, x2) = [0] [0] [c_1](x1) = [1 1] x1 + [0] [0 0] [0] [c_2](x1) = [1 1] x1 + [0] [0 0] [0] [c_10](x1) = [1 0] x1 + [0] [0 0] [0] This order satisfies following ordering constraints [#equal(@x, @y)] = [0 0] @y + [0] [1 0] [1] >= [0 0] @y + [0] [1 0] [1] = [#eq(@x, @y)] [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] = [0 0] @y_2 + [0] [1 0] [3] >= [0] [2] = [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))] [#eq(::(@x_1, @x_2), nil())] = [0] [2] >= [0] [2] = [#false()] [#eq(::(@x_1, @x_2), leaf())] = [0] [2] >= [0] [2] = [#false()] [#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] = [0] [2] >= [0] [2] = [#false()] [#eq(nil(), ::(@y_1, @y_2))] = [0 0] @y_2 + [0] [1 0] [3] >= [0] [2] = [#false()] [#eq(nil(), nil())] = [0] [2] >= [0] [0] = [#true()] [#eq(nil(), leaf())] = [0] [2] >= [0] [2] = [#false()] [#eq(nil(), node(@y_1, @y_2, @y_3))] = [0] [2] >= [0] [2] = [#false()] [#eq(leaf(), ::(@y_1, @y_2))] = [0 0] @y_2 + [0] [1 0] [3] >= [0] [2] = [#false()] [#eq(leaf(), nil())] = [0] [2] >= [0] [2] = [#false()] [#eq(leaf(), leaf())] = [0] [2] >= [0] [0] = [#true()] [#eq(leaf(), node(@y_1, @y_2, @y_3))] = [0] [2] >= [0] [2] = [#false()] [#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] = [0 0] @y_2 + [0] [1 0] [3] >= [0] [2] = [#false()] [#eq(node(@x_1, @x_2, @x_3), nil())] = [0] [2] >= [0] [2] = [#false()] [#eq(node(@x_1, @x_2, @x_3), leaf())] = [0] [2] >= [0] [2] = [#false()] [#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] = [0] [2] >= [0] [2] = [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))] [#eq(#0(), #0())] = [0] [2] >= [0] [0] = [#true()] [#eq(#0(), #neg(@y))] = [0 0] @y + [0] [1 1] [3] >= [0] [2] = [#false()] [#eq(#0(), #pos(@y))] = [0 0] @y + [0] [1 1] [2] >= [0] [2] = [#false()] [#eq(#0(), #s(@y))] = [0 0] @y + [0] [1 1] [3] >= [0] [2] = [#false()] [#eq(#neg(@x), #0())] = [0] [2] >= [0] [2] = [#false()] [#eq(#neg(@x), #neg(@y))] = [0 0] @y + [0] [1 1] [3] >= [0 0] @y + [0] [1 0] [1] = [#eq(@x, @y)] [#eq(#neg(@x), #pos(@y))] = [0 0] @y + [0] [1 1] [2] >= [0] [2] = [#false()] [#eq(#pos(@x), #0())] = [0] [2] >= [0] [2] = [#false()] [#eq(#pos(@x), #neg(@y))] = [0 0] @y + [0] [1 1] [3] >= [0] [2] = [#false()] [#eq(#pos(@x), #pos(@y))] = [0 0] @y + [0] [1 1] [2] >= [0 0] @y + [0] [1 0] [1] = [#eq(@x, @y)] [#eq(#s(@x), #0())] = [0] [2] >= [0] [2] = [#false()] [#eq(#s(@x), #s(@y))] = [0 0] @y + [0] [1 1] [3] >= [0 0] @y + [0] [1 0] [1] = [#eq(@x, @y)] [appendreverse(@toreverse, @sofar)] = [1 0] @sofar + [1 0] @toreverse + [0] [0 1] [0 1] [0] >= [1 0] @sofar + [1 0] @toreverse + [0] [0 1] [0 1] [0] = [appendreverse#1(@toreverse, @sofar)] [appendreverse#1(::(@a, @as), @sofar)] = [0 0] @a + [1 0] @as + [1 0] @sofar + [2] [0 1] [0 1] [0 1] [0] >= [0 0] @a + [1 0] @as + [1 0] @sofar + [2] [0 1] [0 1] [0 1] [0] = [appendreverse(@as, ::(@a, @sofar))] [appendreverse#1(nil(), @sofar)] = [1 0] @sofar + [1] [0 1] [0] > [1 0] @sofar + [0] [0 1] [0] = [@sofar] [bfs(@queue, @futurequeue, @x)] = [0 0] @futurequeue + [0 0] @queue + [2] [0 1] [0 1] [0] >= [0 0] @futurequeue + [0 0] @queue + [2] [0 1] [0 1] [0] = [bfs#1(@queue, @futurequeue, @x)] [bfs#1(::(@t, @ts), @futurequeue, @x)] = [0 0] @futurequeue + [0 0] @t + [0 0] @ts + [2] [0 1] [0 1] [0 1] [0] >= [0 0] @futurequeue + [0 0] @t + [0 0] @ts + [2] [0 1] [0 1] [0 1] [0] = [bfs#3(@t, @futurequeue, @ts, @x)] [bfs#1(nil(), @futurequeue, @x)] = [0 0] @futurequeue + [2] [0 1] [0] >= [0 0] @futurequeue + [2] [0 1] [0] = [bfs#2(@futurequeue, @x)] [bfs#3(leaf(), @futurequeue, @ts, @x)] = [0 0] @futurequeue + [0 0] @ts + [2] [0 1] [0 1] [0] >= [0 0] @futurequeue + [0 0] @ts + [2] [0 1] [0 1] [0] = [bfs(@ts, @futurequeue, @x)] [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0 0] @y + [2] [0 1] [1 1] [1 1] [0 1] [1 0] [1] >= [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0 0] @y + [2] [0 1] [1 1] [1 1] [0 1] [1 0] [1] = [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)] [bfs#2(::(@t, @ts), @x)] = [0 0] @t + [0 0] @ts + [2] [0 1] [0 1] [0] >= [0 0] @t + [0 0] @ts + [2] [0 1] [0 1] [0] = [bfs(reverse(::(@t, @ts)), nil(), @x)] [bfs#2(nil(), @x)] = [2] [0] > [1] [0] = [leaf()] [reverse(@xs)] = [2 0] @xs + [1] [0 1] [0] >= [1 0] @xs + [1] [0 1] [0] = [appendreverse(@xs, nil())] [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0 0] @y + [2] [0 1] [1 1] [1 1] [0 1] [1 0] [1] >= [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [2] [0 1] [0 1] [0 1] [0 1] [0] = [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)] [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0 0] @y + [2] [0 1] [1 1] [1 1] [0 1] [1 0] [1] > [0 0] @t1 + [0 0] @t2 + [0 0] @y + [1] [1 1] [1 1] [1 0] [1] = [node(@y, @t1, @t2)] [dobfs(@t, @x)] = [0 0] @t + [2] [1 1] [0] >= [0 0] @t + [2] [0 1] [0] = [bfs(::(@t, nil()), nil(), @x)] [#and(#false(), #false())] = [0] [2] >= [0] [2] = [#false()] [#and(#false(), #true())] = [0] [2] >= [0] [2] = [#false()] [#and(#true(), #false())] = [0] [2] >= [0] [2] = [#false()] [#and(#true(), #true())] = [0] [2] >= [0] [0] = [#true()] [appendreverse^#(@toreverse, @sofar)] = [1 0] @toreverse + [0] [0 0] [1] >= [1 0] @toreverse + [0] [0 0] [0] = [c_1(appendreverse#1^#(@toreverse, @sofar))] [appendreverse#1^#(::(@a, @as), @sofar)] = [1 0] @as + [2] [0 0] [0] > [1 0] @as + [1] [0 0] [0] = [c_2(appendreverse^#(@as, ::(@a, @sofar)))] [bfs^#(@queue, @futurequeue, @x)] = [1 2] @futurequeue + [0 2] @queue + [2 2] @x + [1] [0 0] [0 0] [0 0] [0] >= [1 2] @futurequeue + [0 2] @queue + [2 2] @x + [1] [0 0] [0 0] [0 0] [0] = [bfs#1^#(@queue, @futurequeue, @x)] [bfs#1^#(::(@t, @ts), @futurequeue, @x)] = [1 2] @futurequeue + [0 2] @t + [0 2] @ts + [2 2] @x + [1] [0 0] [0 0] [0 0] [0 0] [0] >= [1 2] @futurequeue + [0 2] @t + [0 2] @ts + [2 2] @x + [1] [0 0] [0 0] [0 0] [0 0] [0] = [bfs#3^#(@t, @futurequeue, @ts, @x)] [bfs#1^#(nil(), @futurequeue, @x)] = [1 2] @futurequeue + [2 2] @x + [1] [0 0] [0 0] [0] > [1 2] @futurequeue + [2 2] @x + [0] [0 0] [0 0] [0] = [bfs#2^#(@futurequeue, @x)] [bfs#3^#(leaf(), @futurequeue, @ts, @x)] = [1 2] @futurequeue + [0 2] @ts + [2 2] @x + [1] [0 0] [0 0] [0 0] [0] >= [1 2] @futurequeue + [0 2] @ts + [2 2] @x + [1] [0 0] [0 0] [0 0] [0] = [bfs^#(@ts, @futurequeue, @x)] [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] = [1 2] @futurequeue + [2 2] @t1 + [2 2] @t2 + [0 2] @ts + [2 2] @x + [2 0] @y + [3] [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [0] >= [1 2] @futurequeue + [0 2] @t1 + [0 2] @t2 + [0 2] @ts + [2 2] @x + [2 0] @y + [3] [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [0] = [bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)] [bfs#2^#(::(@t, @ts), @x)] = [0 2] @t + [1 2] @ts + [2 2] @x + [2] [0 0] [0 0] [0 0] [0] >= [0 2] @t + [0 2] @ts + [2 2] @x + [2] [0 0] [0 0] [0 0] [0] = [bfs^#(reverse(::(@t, @ts)), nil(), @x)] [bfs#2^#(::(@t, @ts), @x)] = [0 2] @t + [1 2] @ts + [2 2] @x + [2] [0 0] [0 0] [0 0] [0] >= [0 2] @t + [1 2] @ts + [2] [0 0] [0 0] [0] = [reverse^#(::(@t, @ts))] [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] = [1 2] @futurequeue + [0 2] @t1 + [0 2] @t2 + [0 2] @ts + [2 2] @x + [5] [0 0] [0 0] [0 0] [0 0] [0 0] [0] >= [1 2] @futurequeue + [0 2] @t1 + [0 2] @t2 + [0 2] @ts + [2 2] @x + [5] [0 0] [0 0] [0 0] [0 0] [0 0] [0] = [bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)] [reverse^#(@xs)] = [1 2] @xs + [0] [0 0] [0] >= [1 0] @xs + [0] [0 0] [0] = [c_10(appendreverse^#(@xs, nil()))] [bfs2^#(@t, @x)] = [2 2] @t + [2 2] @x + [2] [2 1] [1 1] [1] >= [2 2] @t + [2 2] @x + [2] [0 0] [0 0] [0] = [bfs2#1^#(dobfs(@t, @x), @x)] [bfs2#1^#(@t', @x)] = [0 2] @t' + [2 2] @x + [2] [0 0] [0 0] [0] >= [0 2] @t' + [2 2] @x + [2] [0 0] [0 0] [0] = [dobfs^#(@t', @x)] [dobfs^#(@t, @x)] = [0 2] @t + [2 2] @x + [2] [0 0] [0 0] [0] >= [0 2] @t + [2 2] @x + [2] [0 0] [0 0] [0] = [bfs^#(::(@t, nil()), nil(), @x)] Consider the set of all dependency pairs DPs: { 1: appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , 2: reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , 3: appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , 4: bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) , 5: bfs#1^#(::(@t, @ts), @futurequeue, @x) -> bfs#3^#(@t, @futurequeue, @ts, @x) , 6: bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) , 7: bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) , 8: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , 9: bfs#2^#(::(@t, @ts), @x) -> bfs^#(reverse(::(@t, @ts)), nil(), @x) , 10: bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) , 11: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , 12: bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x) , 13: bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) , 14: dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) } Processor 'matrix interpretation of dimension 2' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {3,6}. These cover all (indirect) predecessors of dependency pairs {1,2,3,6,9,10,12,13,14}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> bfs#3^#(@t, @futurequeue, @ts, @x) , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2^#(::(@t, @ts), @x) -> bfs^#(reverse(::(@t, @ts)), nil(), @x) , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x) , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> bfs#1^#(@queue, @futurequeue, @x) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> bfs#3^#(@t, @futurequeue, @ts, @x) , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> bfs^#(@ts, @futurequeue, @x) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2^#(::(@t, @ts), @x) -> bfs^#(reverse(::(@t, @ts)), nil(), @x) , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x) , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded Wall-time: 13.679367s CPU-time: 105.033s Wall-time: 17.709499s CPU-time: 134.545s S) We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak DPs: { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { appendreverse^#(@toreverse, @sofar) -> c_1(appendreverse#1^#(@toreverse, @sofar)) , appendreverse#1^#(::(@a, @as), @sofar) -> c_2(appendreverse^#(@as, ::(@a, @sofar))) , bfs^#(@queue, @futurequeue, @x) -> c_3(bfs#1^#(@queue, @futurequeue, @x)) , bfs#1^#(::(@t, @ts), @futurequeue, @x) -> c_4(bfs#3^#(@t, @futurequeue, @ts, @x)) , bfs#1^#(nil(), @futurequeue, @x) -> c_5(bfs#2^#(@futurequeue, @x)) , bfs#3^#(leaf(), @futurequeue, @ts, @x) -> c_6(bfs^#(@ts, @futurequeue, @x)) , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) , bfs#2^#(::(@t, @ts), @x) -> c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts))) , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) , bfs2^#(@t, @x) -> c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x)) , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , appendreverse(@toreverse, @sofar) -> appendreverse#1(@toreverse, @sofar) , appendreverse#1(::(@a, @as), @sofar) -> appendreverse(@as, ::(@a, @sofar)) , appendreverse#1(nil(), @sofar) -> @sofar , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x) , bfs#1(::(@t, @ts), @futurequeue, @x) -> bfs#3(@t, @futurequeue, @ts, @x) , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x) , bfs#3(leaf(), @futurequeue, @ts, @x) -> bfs(@ts, @futurequeue, @x) , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) -> bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x) , bfs#2(nil(), @x) -> leaf() , reverse(@xs) -> appendreverse(@xs, nil()) , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) -> bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> node(@y, @t1, @t2) , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x) , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x) , bfs2#1(@t', @x) -> dobfs(@t', @x) , dfs(@queue, @x) -> dfs#1(@queue, @x) , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x) , dfs#1(nil(), @x) -> leaf() , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x) , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) -> dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x) , dfs#3(#false(), @t, @t1, @t2, @ts, @x) -> dfs(::(@t1, ::(@t2, @ts)), @x) , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We replace rewrite rules by usable rules: Weak Usable Rules: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 3: dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#equal](x1, x2) = [0] [#eq](x1, x2) = [0] [::](x1, x2) = [1] x1 + [1] x2 + [0] [nil] = [1] [leaf] = [1] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0] [#false] = [0] [#true] = [0] [#and](x1, x2) = [0] [#0] = [1] [#neg](x1) = [1] x1 + [1] [#pos](x1) = [1] x1 + [1] [#s](x1) = [1] x1 + [1] [#equal^#](x1, x2) = [0] [#eq^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bfs^#](x1, x2, x3) = [0] [bfs#1^#](x1, x2, x3) = [0] [bfs#3^#](x1, x2, x3, x4) = [0] [bfs#2^#](x1, x2) = [0] [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [0] [reverse^#](x1) = [0] [bfs2^#](x1, x2) = [0] [bfs2#1^#](x1, x2) = [0] [dobfs^#](x1, x2) = [0] [dfs^#](x1, x2) = [1] x1 + [0] [dfs#1^#](x1, x2) = [1] x1 + [0] [dfs#2^#](x1, x2, x3, x4) = [1] x1 + [1] x3 + [0] [dfs#3^#](x1, x2, x3, x4, x5, x6) = [1] x3 + [1] x4 + [1] x5 + [0] [dodfs^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [c_14](x1) = [1] x1 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] This order satisfies following ordering constraints [dfs^#(@queue, @x)] = [1] @queue + [0] >= [1] @queue + [0] = [c_14(dfs#1^#(@queue, @x))] [dfs#1^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [0] >= [1] @t + [1] @ts + [0] = [c_15(dfs#2^#(@t, @t, @ts, @x))] [dfs#2^#(leaf(), @t, @ts, @x)] = [1] @ts + [1] > [1] @ts + [0] = [c_16(dfs^#(@ts, @x))] [dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x)] = [1] @a + [1] @t1 + [1] @t2 + [1] @ts + [0] >= [1] @t1 + [1] @t2 + [1] @ts + [0] = [c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))] [dfs#3^#(#false(), @t, @t1, @t2, @ts, @x)] = [1] @t1 + [1] @t2 + [1] @ts + [0] >= [1] @t1 + [1] @t2 + [1] @ts + [0] = [c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x))] The strictly oriented rules are moved into the corresponding weak component(s). We are left with following problem, upon which TcT provides the certificate YES(O(1),O(n^1)). Strict DPs: { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak DPs: { dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } Obligation: innermost runtime complexity Answer: YES(O(1),O(n^1)) We use the processor 'matrix interpretation of dimension 1' to orient following rules strictly. DPs: { 3: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , 5: dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) } Trs: { #eq(nil(), nil()) -> #true() , #eq(leaf(), leaf()) -> #true() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) } Sub-proof: ---------- The following argument positions are usable: Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1}, Uargs(c_17) = {1}, Uargs(c_18) = {1} TcT has computed following constructor-based matrix interpretation satisfying not(EDA). [#equal](x1, x2) = [0] [#eq](x1, x2) = [1] x1 + [0] [::](x1, x2) = [1] x1 + [1] x2 + [0] [nil] = [1] [leaf] = [1] [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1] [#false] = [1] [#true] = [0] [#and](x1, x2) = [0] [#0] = [1] [#neg](x1) = [1] x1 + [1] [#pos](x1) = [1] x1 + [1] [#s](x1) = [1] x1 + [1] [#equal^#](x1, x2) = [0] [#eq^#](x1, x2) = [0] [appendreverse^#](x1, x2) = [0] [appendreverse#1^#](x1, x2) = [0] [bfs^#](x1, x2, x3) = [0] [bfs#1^#](x1, x2, x3) = [0] [bfs#3^#](x1, x2, x3, x4) = [0] [bfs#2^#](x1, x2) = [0] [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [0] [reverse^#](x1) = [0] [bfs2^#](x1, x2) = [0] [bfs2#1^#](x1, x2) = [0] [dobfs^#](x1, x2) = [0] [dfs^#](x1, x2) = [1] x1 + [0] [dfs#1^#](x1, x2) = [1] x1 + [0] [dfs#2^#](x1, x2, x3, x4) = [1] x1 + [1] x3 + [0] [dfs#3^#](x1, x2, x3, x4, x5, x6) = [1] x3 + [1] x4 + [1] x5 + [0] [dodfs^#](x1, x2) = [0] [#and^#](x1, x2) = [0] [c_14](x1) = [1] x1 + [0] [c_15](x1) = [1] x1 + [0] [c_16](x1) = [1] x1 + [0] [c_17](x1) = [1] x1 + [0] [c_18](x1) = [1] x1 + [0] This order satisfies following ordering constraints [dfs^#(@queue, @x)] = [1] @queue + [0] >= [1] @queue + [0] = [c_14(dfs#1^#(@queue, @x))] [dfs#1^#(::(@t, @ts), @x)] = [1] @t + [1] @ts + [0] >= [1] @t + [1] @ts + [0] = [c_15(dfs#2^#(@t, @t, @ts, @x))] [dfs#2^#(leaf(), @t, @ts, @x)] = [1] @ts + [1] > [1] @ts + [0] = [c_16(dfs^#(@ts, @x))] [dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x)] = [1] @a + [1] @t1 + [1] @t2 + [1] @ts + [1] > [1] @t1 + [1] @t2 + [1] @ts + [0] = [c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))] [dfs#3^#(#false(), @t, @t1, @t2, @ts, @x)] = [1] @t1 + [1] @t2 + [1] @ts + [0] >= [1] @t1 + [1] @t2 + [1] @ts + [0] = [c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x))] Consider the set of all dependency pairs DPs: { 1: dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , 2: dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , 3: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , 4: dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) , 5: dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) } Processor 'matrix interpretation of dimension 1' induces the complexity certificate YES(?,O(n^1)) on application of dependency pairs {3,5}. These cover all (indirect) predecessors of dependency pairs {1,2,3,4,5}, their number of application is equally bounded. The dependency pairs are shifted into the corresponding weak component(s). We apply the transformation 'removetails' on the sub-problem: Weak DPs: { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } StartTerms: basic terms Strategy: innermost The following weak DPs constitute a sub-graph of the DG that is closed under successors. The DPs are removed. { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x)) , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x)) , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) -> c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x)) , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) -> c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) } We apply the transformation 'usablerules' on the sub-problem: Weak Trs: { #equal(@x, @y) -> #eq(@x, @y) , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) -> #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2)) , #eq(::(@x_1, @x_2), nil()) -> #false() , #eq(::(@x_1, @x_2), leaf()) -> #false() , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false() , #eq(nil(), ::(@y_1, @y_2)) -> #false() , #eq(nil(), nil()) -> #true() , #eq(nil(), leaf()) -> #false() , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(leaf(), ::(@y_1, @y_2)) -> #false() , #eq(leaf(), nil()) -> #false() , #eq(leaf(), leaf()) -> #true() , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false() , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false() , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false() , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false() , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) -> #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))) , #eq(#0(), #0()) -> #true() , #eq(#0(), #neg(@y)) -> #false() , #eq(#0(), #pos(@y)) -> #false() , #eq(#0(), #s(@y)) -> #false() , #eq(#neg(@x), #0()) -> #false() , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y) , #eq(#neg(@x), #pos(@y)) -> #false() , #eq(#pos(@x), #0()) -> #false() , #eq(#pos(@x), #neg(@y)) -> #false() , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y) , #eq(#s(@x), #0()) -> #false() , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) , #and(#false(), #false()) -> #false() , #and(#false(), #true()) -> #false() , #and(#true(), #false()) -> #false() , #and(#true(), #true()) -> #true() } StartTerms: basic terms Strategy: innermost No rule is usable, rules are removed from the input problem. We are left with following problem, upon which TcT provides the certificate YES(O(1),O(1)). Rules: Empty Obligation: innermost runtime complexity Answer: YES(O(1),O(1)) Empty rules are trivially bounded Wall-time: 0.923161s CPU-time: 8.993s Hurray, we answered YES(O(1),O(n^2))